Google Git
Sign in
flutter / third_party / googleapis.dart / 5889af77944482253b38a6c369d4fe72f316855c / . / generated / googleapis / lib / androidmanagement / v1.dart
blob: 887f71bf495c8ef0e6aab8150de391ba70236dab [file] [log] [blame]
// This is a generated file (see the discoveryapis_generator project).
// ignore_for_file: camel_case_types
// ignore_for_file: comment_references
// ignore_for_file: file_names
// ignore_for_file: library_names
// ignore_for_file: lines_longer_than_80_chars
// ignore_for_file: non_constant_identifier_names
// ignore_for_file: prefer_expression_function_bodies
// ignore_for_file: prefer_final_locals
// ignore_for_file: prefer_interpolation_to_compose_strings
// ignore_for_file: unnecessary_brace_in_string_interps
// ignore_for_file: unnecessary_cast
// ignore_for_file: unnecessary_lambdas
// ignore_for_file: unnecessary_parenthesis
// ignore_for_file: unnecessary_string_interpolations
/// Android Management API - v1
///
/// The Android Management API provides remote enterprise management of Android
/// devices and apps.
///
/// For more information, see <https://developers.google.com/android/management>
library androidmanagement.v1;
import 'dart:async' as async;
import 'dart:convert' as convert;
import 'dart:core' as core;
import 'package:_discoveryapis_commons/_discoveryapis_commons.dart' as commons;
import 'package:http/http.dart' as http;
import '../src/user_agent.dart';
export 'package:_discoveryapis_commons/_discoveryapis_commons.dart'
show ApiRequestError, DetailedApiRequestError;
/// The Android Management API provides remote enterprise management of Android
/// devices and apps.
class AndroidManagementApi {
/// Manage Android devices and apps for your customers
static const androidmanagementScope =
'https://www.googleapis.com/auth/androidmanagement';
final commons.ApiRequester _requester;
EnterprisesResourceApi get enterprises => EnterprisesResourceApi(_requester);
SignupUrlsResourceApi get signupUrls => SignupUrlsResourceApi(_requester);
AndroidManagementApi(http.Client client,
{core.String rootUrl = 'https://androidmanagement.googleapis.com/',
core.String servicePath = ''})
: _requester =
commons.ApiRequester(client, rootUrl, servicePath, userAgent);
}
class EnterprisesResourceApi {
final commons.ApiRequester _requester;
EnterprisesApplicationsResourceApi get applications =>
EnterprisesApplicationsResourceApi(_requester);
EnterprisesDevicesResourceApi get devices =>
EnterprisesDevicesResourceApi(_requester);
EnterprisesEnrollmentTokensResourceApi get enrollmentTokens =>
EnterprisesEnrollmentTokensResourceApi(_requester);
EnterprisesPoliciesResourceApi get policies =>
EnterprisesPoliciesResourceApi(_requester);
EnterprisesWebAppsResourceApi get webApps =>
EnterprisesWebAppsResourceApi(_requester);
EnterprisesWebTokensResourceApi get webTokens =>
EnterprisesWebTokensResourceApi(_requester);
EnterprisesResourceApi(commons.ApiRequester client) : _requester = client;
/// Creates an enterprise. This is the last step in the enterprise signup
/// flow.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [enterpriseToken] - The enterprise token appended to the callback URL.
///
/// [projectId] - The ID of the Google Cloud Platform project which will own
/// the enterprise.
///
/// [signupUrlName] - The name of the SignupUrl used to sign up for the
/// enterprise.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Enterprise].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Enterprise> create(
Enterprise request, {
core.String enterpriseToken,
core.String projectId,
core.String signupUrlName,
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (request != null) {
_body = convert.json.encode(request.toJson());
}
if (enterpriseToken != null) {
_queryParams['enterpriseToken'] = [enterpriseToken];
}
if (projectId != null) {
_queryParams['projectId'] = [projectId];
}
if (signupUrlName != null) {
_queryParams['signupUrlName'] = [signupUrlName];
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'v1/enterprises';
final _response = _requester.request(
_url,
'POST',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) =>
Enterprise.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
/// Gets an enterprise.
///
/// Request parameters:
///
/// [name] - The name of the enterprise in the form
/// enterprises/{enterpriseId}.
/// Value must have pattern "^enterprises/[^/]+$".
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Enterprise].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Enterprise> get(
core.String name, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (name == null) {
throw core.ArgumentError('Parameter name is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name');
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) =>
Enterprise.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
/// Updates an enterprise.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [name] - The name of the enterprise in the form
/// enterprises/{enterpriseId}.
/// Value must have pattern "^enterprises/[^/]+$".
///
/// [updateMask] - The field mask indicating the fields to update. If not set,
/// all modifiable fields will be modified.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Enterprise].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Enterprise> patch(
Enterprise request,
core.String name, {
core.String updateMask,
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (request != null) {
_body = convert.json.encode(request.toJson());
}
if (name == null) {
throw core.ArgumentError('Parameter name is required.');
}
if (updateMask != null) {
_queryParams['updateMask'] = [updateMask];
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name');
final _response = _requester.request(
_url,
'PATCH',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) =>
Enterprise.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
}
class EnterprisesApplicationsResourceApi {
final commons.ApiRequester _requester;
EnterprisesApplicationsResourceApi(commons.ApiRequester client)
: _requester = client;
/// Gets info about an application.
///
/// Request parameters:
///
/// [name] - The name of the application in the form
/// enterprises/{enterpriseId}/applications/{package_name}.
/// Value must have pattern "^enterprises/[^/]+/applications/[^/]+$".
///
/// [languageCode] - The preferred language for localized application info, as
/// a BCP47 tag (e.g. "en-US", "de"). If not specified the default language of
/// the application will be used.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Application].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Application> get(
core.String name, {
core.String languageCode,
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (name == null) {
throw core.ArgumentError('Parameter name is required.');
}
if (languageCode != null) {
_queryParams['languageCode'] = [languageCode];
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name');
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) =>
Application.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
}
class EnterprisesDevicesResourceApi {
final commons.ApiRequester _requester;
EnterprisesDevicesOperationsResourceApi get operations =>
EnterprisesDevicesOperationsResourceApi(_requester);
EnterprisesDevicesResourceApi(commons.ApiRequester client)
: _requester = client;
/// Deletes a device. This operation wipes the device.
///
/// Request parameters:
///
/// [name] - The name of the device in the form
/// enterprises/{enterpriseId}/devices/{deviceId}.
/// Value must have pattern "^enterprises/[^/]+/devices/[^/]+$".
///
/// [wipeDataFlags] - Optional flags that control the device wiping behavior.
///
/// [wipeReasonMessage] - Optional. A short message displayed to the user
/// before wiping the work profile on personal devices. This has no effect on
/// company owned devices. The maximum message length is 200 characters.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Empty].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Empty> delete(
core.String name, {
core.List<core.String> wipeDataFlags,
core.String wipeReasonMessage,
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (name == null) {
throw core.ArgumentError('Parameter name is required.');
}
if (wipeDataFlags != null) {
_queryParams['wipeDataFlags'] = wipeDataFlags;
}
if (wipeReasonMessage != null) {
_queryParams['wipeReasonMessage'] = [wipeReasonMessage];
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name');
final _response = _requester.request(
_url,
'DELETE',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => Empty.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
/// Gets a device.
///
/// Request parameters:
///
/// [name] - The name of the device in the form
/// enterprises/{enterpriseId}/devices/{deviceId}.
/// Value must have pattern "^enterprises/[^/]+/devices/[^/]+$".
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Device].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Device> get(
core.String name, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (name == null) {
throw core.ArgumentError('Parameter name is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name');
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => Device.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
/// Issues a command to a device. The Operation resource returned contains a
/// Command in its metadata field. Use the get operation method to get the
/// status of the command.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [name] - The name of the device in the form
/// enterprises/{enterpriseId}/devices/{deviceId}.
/// Value must have pattern "^enterprises/[^/]+/devices/[^/]+$".
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Operation].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Operation> issueCommand(
Command request,
core.String name, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (request != null) {
_body = convert.json.encode(request.toJson());
}
if (name == null) {
throw core.ArgumentError('Parameter name is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'v1/' +
commons.Escaper.ecapeVariableReserved('$name') +
':issueCommand';
final _response = _requester.request(
_url,
'POST',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => Operation.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
/// Lists devices for a given enterprise.
///
/// Request parameters:
///
/// [parent] - The name of the enterprise in the form
/// enterprises/{enterpriseId}.
/// Value must have pattern "^enterprises/[^/]+$".
///
/// [pageSize] - The requested page size. The actual page size may be fixed to
/// a min or max value.
///
/// [pageToken] - A token identifying a page of results returned by the
/// server.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListDevicesResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ListDevicesResponse> list(
core.String parent, {
core.int pageSize,
core.String pageToken,
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (parent == null) {
throw core.ArgumentError('Parameter parent is required.');
}
if (pageSize != null) {
_queryParams['pageSize'] = ['${pageSize}'];
}
if (pageToken != null) {
_queryParams['pageToken'] = [pageToken];
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url =
'v1/' + commons.Escaper.ecapeVariableReserved('$parent') + '/devices';
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => ListDevicesResponse.fromJson(
data as core.Map<core.String, core.dynamic>),
);
}
/// Updates a device.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [name] - The name of the device in the form
/// enterprises/{enterpriseId}/devices/{deviceId}.
/// Value must have pattern "^enterprises/[^/]+/devices/[^/]+$".
///
/// [updateMask] - The field mask indicating the fields to update. If not set,
/// all modifiable fields will be modified.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Device].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Device> patch(
Device request,
core.String name, {
core.String updateMask,
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (request != null) {
_body = convert.json.encode(request.toJson());
}
if (name == null) {
throw core.ArgumentError('Parameter name is required.');
}
if (updateMask != null) {
_queryParams['updateMask'] = [updateMask];
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name');
final _response = _requester.request(
_url,
'PATCH',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => Device.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
}
class EnterprisesDevicesOperationsResourceApi {
final commons.ApiRequester _requester;
EnterprisesDevicesOperationsResourceApi(commons.ApiRequester client)
: _requester = client;
/// Starts asynchronous cancellation on a long-running operation. The server
/// makes a best effort to cancel the operation, but success is not
/// guaranteed. If the server doesn't support this method, it returns
/// google.rpc.Code.UNIMPLEMENTED. Clients can use Operations.GetOperation or
/// other methods to check whether the cancellation succeeded or whether the
/// operation completed despite cancellation. On successful cancellation, the
/// operation is not deleted; instead, it becomes an operation with an
/// Operation.error value with a google.rpc.Status.code of 1, corresponding to
/// Code.CANCELLED.
///
/// Request parameters:
///
/// [name] - The name of the operation resource to be cancelled.
/// Value must have pattern
/// "^enterprises/[^/]+/devices/[^/]+/operations/[^/]+$".
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Empty].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Empty> cancel(
core.String name, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (name == null) {
throw core.ArgumentError('Parameter name is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name') + ':cancel';
final _response = _requester.request(
_url,
'POST',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => Empty.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
/// Deletes a long-running operation. This method indicates that the client is
/// no longer interested in the operation result. It does not cancel the
/// operation. If the server doesn't support this method, it returns
/// google.rpc.Code.UNIMPLEMENTED.
///
/// Request parameters:
///
/// [name] - The name of the operation resource to be deleted.
/// Value must have pattern
/// "^enterprises/[^/]+/devices/[^/]+/operations/[^/]+$".
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Empty].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Empty> delete(
core.String name, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (name == null) {
throw core.ArgumentError('Parameter name is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name');
final _response = _requester.request(
_url,
'DELETE',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => Empty.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
/// Gets the latest state of a long-running operation. Clients can use this
/// method to poll the operation result at intervals as recommended by the API
/// service.
///
/// Request parameters:
///
/// [name] - The name of the operation resource.
/// Value must have pattern
/// "^enterprises/[^/]+/devices/[^/]+/operations/[^/]+$".
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Operation].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Operation> get(
core.String name, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (name == null) {
throw core.ArgumentError('Parameter name is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name');
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => Operation.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
/// Lists operations that match the specified filter in the request. If the
/// server doesn't support this method, it returns UNIMPLEMENTED.NOTE: the
/// name binding allows API services to override the binding to use different
/// resource name schemes, such as users / * /operations. To override the
/// binding, API services can add a binding such as "/v1/{name=users / *
/// }/operations" to their service configuration. For backwards compatibility,
/// the default name includes the operations collection id, however overriding
/// users must ensure the name binding is the parent resource, without the
/// operations collection id.
///
/// Request parameters:
///
/// [name] - The name of the operation's parent resource.
/// Value must have pattern "^enterprises/[^/]+/devices/[^/]+/operations$".
///
/// [filter] - The standard list filter.
///
/// [pageSize] - The standard list page size.
///
/// [pageToken] - The standard list page token.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListOperationsResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ListOperationsResponse> list(
core.String name, {
core.String filter,
core.int pageSize,
core.String pageToken,
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (name == null) {
throw core.ArgumentError('Parameter name is required.');
}
if (filter != null) {
_queryParams['filter'] = [filter];
}
if (pageSize != null) {
_queryParams['pageSize'] = ['${pageSize}'];
}
if (pageToken != null) {
_queryParams['pageToken'] = [pageToken];
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name');
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => ListOperationsResponse.fromJson(
data as core.Map<core.String, core.dynamic>),
);
}
}
class EnterprisesEnrollmentTokensResourceApi {
final commons.ApiRequester _requester;
EnterprisesEnrollmentTokensResourceApi(commons.ApiRequester client)
: _requester = client;
/// Creates an enrollment token for a given enterprise.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [parent] - The name of the enterprise in the form
/// enterprises/{enterpriseId}.
/// Value must have pattern "^enterprises/[^/]+$".
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [EnrollmentToken].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<EnrollmentToken> create(
EnrollmentToken request,
core.String parent, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (request != null) {
_body = convert.json.encode(request.toJson());
}
if (parent == null) {
throw core.ArgumentError('Parameter parent is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'v1/' +
commons.Escaper.ecapeVariableReserved('$parent') +
'/enrollmentTokens';
final _response = _requester.request(
_url,
'POST',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) =>
EnrollmentToken.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
/// Deletes an enrollment token. This operation invalidates the token,
/// preventing its future use.
///
/// Request parameters:
///
/// [name] - The name of the enrollment token in the form
/// enterprises/{enterpriseId}/enrollmentTokens/{enrollmentTokenId}.
/// Value must have pattern "^enterprises/[^/]+/enrollmentTokens/[^/]+$".
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Empty].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Empty> delete(
core.String name, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (name == null) {
throw core.ArgumentError('Parameter name is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name');
final _response = _requester.request(
_url,
'DELETE',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => Empty.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
}
class EnterprisesPoliciesResourceApi {
final commons.ApiRequester _requester;
EnterprisesPoliciesResourceApi(commons.ApiRequester client)
: _requester = client;
/// Deletes a policy. This operation is only permitted if no devices are
/// currently referencing the policy.
///
/// Request parameters:
///
/// [name] - The name of the policy in the form
/// enterprises/{enterpriseId}/policies/{policyId}.
/// Value must have pattern "^enterprises/[^/]+/policies/[^/]+$".
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Empty].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Empty> delete(
core.String name, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (name == null) {
throw core.ArgumentError('Parameter name is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name');
final _response = _requester.request(
_url,
'DELETE',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => Empty.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
/// Gets a policy.
///
/// Request parameters:
///
/// [name] - The name of the policy in the form
/// enterprises/{enterpriseId}/policies/{policyId}.
/// Value must have pattern "^enterprises/[^/]+/policies/[^/]+$".
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Policy].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Policy> get(
core.String name, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (name == null) {
throw core.ArgumentError('Parameter name is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name');
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => Policy.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
/// Lists policies for a given enterprise.
///
/// Request parameters:
///
/// [parent] - The name of the enterprise in the form
/// enterprises/{enterpriseId}.
/// Value must have pattern "^enterprises/[^/]+$".
///
/// [pageSize] - The requested page size. The actual page size may be fixed to
/// a min or max value.
///
/// [pageToken] - A token identifying a page of results returned by the
/// server.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListPoliciesResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ListPoliciesResponse> list(
core.String parent, {
core.int pageSize,
core.String pageToken,
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (parent == null) {
throw core.ArgumentError('Parameter parent is required.');
}
if (pageSize != null) {
_queryParams['pageSize'] = ['${pageSize}'];
}
if (pageToken != null) {
_queryParams['pageToken'] = [pageToken];
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url =
'v1/' + commons.Escaper.ecapeVariableReserved('$parent') + '/policies';
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => ListPoliciesResponse.fromJson(
data as core.Map<core.String, core.dynamic>),
);
}
/// Updates or creates a policy.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [name] - The name of the policy in the form
/// enterprises/{enterpriseId}/policies/{policyId}.
/// Value must have pattern "^enterprises/[^/]+/policies/[^/]+$".
///
/// [updateMask] - The field mask indicating the fields to update. If not set,
/// all modifiable fields will be modified.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Policy].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Policy> patch(
Policy request,
core.String name, {
core.String updateMask,
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (request != null) {
_body = convert.json.encode(request.toJson());
}
if (name == null) {
throw core.ArgumentError('Parameter name is required.');
}
if (updateMask != null) {
_queryParams['updateMask'] = [updateMask];
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name');
final _response = _requester.request(
_url,
'PATCH',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => Policy.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
}
class EnterprisesWebAppsResourceApi {
final commons.ApiRequester _requester;
EnterprisesWebAppsResourceApi(commons.ApiRequester client)
: _requester = client;
/// Creates a web app.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [parent] - The name of the enterprise in the form
/// enterprises/{enterpriseId}.
/// Value must have pattern "^enterprises/[^/]+$".
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [WebApp].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<WebApp> create(
WebApp request,
core.String parent, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (request != null) {
_body = convert.json.encode(request.toJson());
}
if (parent == null) {
throw core.ArgumentError('Parameter parent is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url =
'v1/' + commons.Escaper.ecapeVariableReserved('$parent') + '/webApps';
final _response = _requester.request(
_url,
'POST',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => WebApp.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
/// Deletes a web app.
///
/// Request parameters:
///
/// [name] - The name of the web app in the form
/// enterprises/{enterpriseId}/webApps/{packageName}.
/// Value must have pattern "^enterprises/[^/]+/webApps/[^/]+$".
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Empty].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<Empty> delete(
core.String name, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (name == null) {
throw core.ArgumentError('Parameter name is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name');
final _response = _requester.request(
_url,
'DELETE',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => Empty.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
/// Gets a web app.
///
/// Request parameters:
///
/// [name] - The name of the web app in the form
/// enterprises/{enterpriseId}/webApp/{packageName}.
/// Value must have pattern "^enterprises/[^/]+/webApps/[^/]+$".
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [WebApp].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<WebApp> get(
core.String name, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (name == null) {
throw core.ArgumentError('Parameter name is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name');
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => WebApp.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
/// Lists web apps for a given enterprise.
///
/// Request parameters:
///
/// [parent] - The name of the enterprise in the form
/// enterprises/{enterpriseId}.
/// Value must have pattern "^enterprises/[^/]+$".
///
/// [pageSize] - The requested page size. The actual page size may be fixed to
/// a min or max value.
///
/// [pageToken] - A token identifying a page of results returned by the
/// server.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListWebAppsResponse].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<ListWebAppsResponse> list(
core.String parent, {
core.int pageSize,
core.String pageToken,
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (parent == null) {
throw core.ArgumentError('Parameter parent is required.');
}
if (pageSize != null) {
_queryParams['pageSize'] = ['${pageSize}'];
}
if (pageToken != null) {
_queryParams['pageToken'] = [pageToken];
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url =
'v1/' + commons.Escaper.ecapeVariableReserved('$parent') + '/webApps';
final _response = _requester.request(
_url,
'GET',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => ListWebAppsResponse.fromJson(
data as core.Map<core.String, core.dynamic>),
);
}
/// Updates a web app.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [name] - The name of the web app in the form
/// enterprises/{enterpriseId}/webApps/{packageName}.
/// Value must have pattern "^enterprises/[^/]+/webApps/[^/]+$".
///
/// [updateMask] - The field mask indicating the fields to update. If not set,
/// all modifiable fields will be modified.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [WebApp].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<WebApp> patch(
WebApp request,
core.String name, {
core.String updateMask,
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (request != null) {
_body = convert.json.encode(request.toJson());
}
if (name == null) {
throw core.ArgumentError('Parameter name is required.');
}
if (updateMask != null) {
_queryParams['updateMask'] = [updateMask];
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'v1/' + commons.Escaper.ecapeVariableReserved('$name');
final _response = _requester.request(
_url,
'PATCH',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => WebApp.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
}
class EnterprisesWebTokensResourceApi {
final commons.ApiRequester _requester;
EnterprisesWebTokensResourceApi(commons.ApiRequester client)
: _requester = client;
/// Creates a web token to access an embeddable managed Google Play web UI for
/// a given enterprise.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [parent] - The name of the enterprise in the form
/// enterprises/{enterpriseId}.
/// Value must have pattern "^enterprises/[^/]+$".
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [WebToken].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<WebToken> create(
WebToken request,
core.String parent, {
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (request != null) {
_body = convert.json.encode(request.toJson());
}
if (parent == null) {
throw core.ArgumentError('Parameter parent is required.');
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url =
'v1/' + commons.Escaper.ecapeVariableReserved('$parent') + '/webTokens';
final _response = _requester.request(
_url,
'POST',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => WebToken.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
}
class SignupUrlsResourceApi {
final commons.ApiRequester _requester;
SignupUrlsResourceApi(commons.ApiRequester client) : _requester = client;
/// Creates an enterprise signup URL.
///
/// Request parameters:
///
/// [callbackUrl] - The callback URL that the admin will be redirected to
/// after successfully creating an enterprise. Before redirecting there the
/// system will add a query parameter to this URL named enterpriseToken which
/// will contain an opaque token to be used for the create enterprise request.
/// The URL will be parsed then reformatted in order to add the
/// enterpriseToken parameter, so there may be some minor formatting changes.
///
/// [projectId] - The ID of the Google Cloud Platform project which will own
/// the enterprise.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [SignupUrl].
///
/// Completes with a [commons.ApiRequestError] if the API endpoint returned an
/// error.
///
/// If the used [http.Client] completes with an error when making a REST call,
/// this method will complete with the same error.
async.Future<SignupUrl> create({
core.String callbackUrl,
core.String projectId,
core.String $fields,
}) {
core.String _url;
final _queryParams = <core.String, core.List<core.String>>{};
commons.Media _uploadMedia;
commons.UploadOptions _uploadOptions;
var _downloadOptions = commons.DownloadOptions.Metadata;
core.String _body;
if (callbackUrl != null) {
_queryParams['callbackUrl'] = [callbackUrl];
}
if (projectId != null) {
_queryParams['projectId'] = [projectId];
}
if ($fields != null) {
_queryParams['fields'] = [$fields];
}
_url = 'v1/signupUrls';
final _response = _requester.request(
_url,
'POST',
body: _body,
queryParams: _queryParams,
uploadOptions: _uploadOptions,
uploadMedia: _uploadMedia,
downloadOptions: _downloadOptions,
);
return _response.then(
(data) => SignupUrl.fromJson(data as core.Map<core.String, core.dynamic>),
);
}
}
/// Security policies set to the most secure values by default. To maintain the
/// security posture of a device, we don't recommend overriding any of the
/// default values.
class AdvancedSecurityOverrides {
/// The policy for untrusted apps (apps from unknown sources) enforced on the
/// device. Replaces install_unknown_sources_allowed (deprecated).
/// Possible string values are:
/// - "UNTRUSTED_APPS_POLICY_UNSPECIFIED" : Unspecified. Defaults to
/// DISALLOW_INSTALL.
/// - "DISALLOW_INSTALL" : Default. Disallow untrusted app installs on entire
/// device.
/// - "ALLOW_INSTALL_IN_PERSONAL_PROFILE_ONLY" : For devices with work
/// profiles, allow untrusted app installs in the device's personal profile
/// only.
/// - "ALLOW_INSTALL_DEVICE_WIDE" : Allow untrusted app installs on entire
/// device.
core.String untrustedAppsPolicy;
AdvancedSecurityOverrides();
AdvancedSecurityOverrides.fromJson(core.Map _json) {
if (_json.containsKey('untrustedAppsPolicy')) {
untrustedAppsPolicy = _json['untrustedAppsPolicy'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (untrustedAppsPolicy != null) {
_json['untrustedAppsPolicy'] = untrustedAppsPolicy;
}
return _json;
}
}
/// Configuration for an always-on VPN connection.
class AlwaysOnVpnPackage {
/// Disallows networking when the VPN is not connected.
core.bool lockdownEnabled;
/// The package name of the VPN app.
core.String packageName;
AlwaysOnVpnPackage();
AlwaysOnVpnPackage.fromJson(core.Map _json) {
if (_json.containsKey('lockdownEnabled')) {
lockdownEnabled = _json['lockdownEnabled'] as core.bool;
}
if (_json.containsKey('packageName')) {
packageName = _json['packageName'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (lockdownEnabled != null) {
_json['lockdownEnabled'] = lockdownEnabled;
}
if (packageName != null) {
_json['packageName'] = packageName;
}
return _json;
}
}
/// A compliance rule condition which is satisfied if the Android Framework API
/// level on the device doesn't meet a minimum requirement. There can only be
/// one rule with this type of condition per policy.
class ApiLevelCondition {
/// The minimum desired Android Framework API level. If the device doesn't
/// meet the minimum requirement, this condition is satisfied. Must be greater
/// than zero.
core.int minApiLevel;
ApiLevelCondition();
ApiLevelCondition.fromJson(core.Map _json) {
if (_json.containsKey('minApiLevel')) {
minApiLevel = _json['minApiLevel'] as core.int;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (minApiLevel != null) {
_json['minApiLevel'] = minApiLevel;
}
return _json;
}
}
/// Id to name association of a app track.
class AppTrackInfo {
/// The track name associated with the trackId, set in the Play Console. The
/// name is modifiable from Play Console.
core.String trackAlias;
/// The unmodifiable unique track identifier, taken from the releaseTrackId in
/// the URL of the Play Console page that displays the app’s track
/// information.
core.String trackId;
AppTrackInfo();
AppTrackInfo.fromJson(core.Map _json) {
if (_json.containsKey('trackAlias')) {
trackAlias = _json['trackAlias'] as core.String;
}
if (_json.containsKey('trackId')) {
trackId = _json['trackId'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (trackAlias != null) {
_json['trackAlias'] = trackAlias;
}
if (trackId != null) {
_json['trackId'] = trackId;
}
return _json;
}
}
/// Information about an app.
class Application {
/// Application tracks visible to the enterprise.
core.List<AppTrackInfo> appTracks;
/// The set of managed properties available to be pre-configured for the app.
core.List<ManagedProperty> managedProperties;
/// The name of the app in the form
/// enterprises/{enterpriseId}/applications/{package_name}.
core.String name;
/// The permissions required by the app.
core.List<ApplicationPermission> permissions;
/// The title of the app. Localized.
core.String title;
Application();
Application.fromJson(core.Map _json) {
if (_json.containsKey('appTracks')) {
appTracks = (_json['appTracks'] as core.List)
.map<AppTrackInfo>((value) => AppTrackInfo.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('managedProperties')) {
managedProperties = (_json['managedProperties'] as core.List)
.map<ManagedProperty>((value) => ManagedProperty.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('name')) {
name = _json['name'] as core.String;
}
if (_json.containsKey('permissions')) {
permissions = (_json['permissions'] as core.List)
.map<ApplicationPermission>((value) => ApplicationPermission.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('title')) {
title = _json['title'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (appTracks != null) {
_json['appTracks'] = appTracks.map((value) => value.toJson()).toList();
}
if (managedProperties != null) {
_json['managedProperties'] =
managedProperties.map((value) => value.toJson()).toList();
}
if (name != null) {
_json['name'] = name;
}
if (permissions != null) {
_json['permissions'] =
permissions.map((value) => value.toJson()).toList();
}
if (title != null) {
_json['title'] = title;
}
return _json;
}
}
/// An app-related event.
class ApplicationEvent {
/// The creation time of the event.
core.String createTime;
/// App event type.
/// Possible string values are:
/// - "APPLICATION_EVENT_TYPE_UNSPECIFIED" : This value is disallowed.
/// - "INSTALLED" : The app was installed.
/// - "CHANGED" : The app was changed, for example, a component was enabled or
/// disabled.
/// - "DATA_CLEARED" : The app data was cleared.
/// - "REMOVED" : The app was removed.
/// - "REPLACED" : A new version of the app has been installed, replacing the
/// old version.
/// - "RESTARTED" : The app was restarted.
/// - "PINNED" : The app was pinned to the foreground.
/// - "UNPINNED" : The app was unpinned.
core.String eventType;
ApplicationEvent();
ApplicationEvent.fromJson(core.Map _json) {
if (_json.containsKey('createTime')) {
createTime = _json['createTime'] as core.String;
}
if (_json.containsKey('eventType')) {
eventType = _json['eventType'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (createTime != null) {
_json['createTime'] = createTime;
}
if (eventType != null) {
_json['eventType'] = eventType;
}
return _json;
}
}
/// A permission required by the app.
class ApplicationPermission {
/// A longer description of the permission, providing more detail on what it
/// affects. Localized.
core.String description;
/// The name of the permission. Localized.
core.String name;
/// An opaque string uniquely identifying the permission. Not localized.
core.String permissionId;
ApplicationPermission();
ApplicationPermission.fromJson(core.Map _json) {
if (_json.containsKey('description')) {
description = _json['description'] as core.String;
}
if (_json.containsKey('name')) {
name = _json['name'] as core.String;
}
if (_json.containsKey('permissionId')) {
permissionId = _json['permissionId'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (description != null) {
_json['description'] = description;
}
if (name != null) {
_json['name'] = name;
}
if (permissionId != null) {
_json['permissionId'] = permissionId;
}
return _json;
}
}
/// Policy for an individual app.
class ApplicationPolicy {
/// List of the app’s track IDs that a device belonging to the enterprise can
/// access. If the list contains multiple track IDs, devices receive the
/// latest version among all accessible tracks. If the list contains no track
/// IDs, devices only have access to the app’s production track. More details
/// about each track are available in AppTrackInfo.
core.List<core.String> accessibleTrackIds;
/// Controls whether the app can communicate with itself across a device’s
/// work and personal profiles, subject to user consent.
/// Possible string values are:
/// - "CONNECTED_WORK_AND_PERSONAL_APP_UNSPECIFIED" : Unspecified. Defaults to
/// CONNECTED_WORK_AND_PERSONAL_APPS_DISALLOWED.
/// - "CONNECTED_WORK_AND_PERSONAL_APP_DISALLOWED" : Default. Prevents the app
/// from communicating cross-profile.
/// - "CONNECTED_WORK_AND_PERSONAL_APP_ALLOWED" : Allows the app to
/// communicate across profiles after receiving user consent.
core.String connectedWorkAndPersonalApp;
/// The default policy for all permissions requested by the app. If specified,
/// this overrides the policy-level default_permission_policy which applies to
/// all apps. It does not override the permission_grants which applies to all
/// apps.
/// Possible string values are:
/// - "PERMISSION_POLICY_UNSPECIFIED" : Policy not specified. If no policy is
/// specified for a permission at any level, then the PROMPT behavior is used
/// by default.
/// - "PROMPT" : Prompt the user to grant a permission.
/// - "GRANT" : Automatically grant a permission.
/// - "DENY" : Automatically deny a permission.
core.String defaultPermissionPolicy;
/// The scopes delegated to the app from Android Device Policy.
core.List<core.String> delegatedScopes;
/// Whether the app is disabled. When disabled, the app data is still
/// preserved.
core.bool disabled;
/// The type of installation to perform.
/// Possible string values are:
/// - "INSTALL_TYPE_UNSPECIFIED" : Unspecified. Defaults to AVAILABLE.
/// - "PREINSTALLED" : The app is automatically installed and can be removed
/// by the user.
/// - "FORCE_INSTALLED" : The app is automatically installed and can't be
/// removed by the user.
/// - "BLOCKED" : The app is blocked and can't be installed. If the app was
/// installed under a previous policy, it will be uninstalled.
/// - "AVAILABLE" : The app is available to install.
/// - "REQUIRED_FOR_SETUP" : The app is automatically installed and can't be
/// removed by the user and will prevent setup from completion until
/// installation is complete.
/// - "KIOSK" : The app is automatically installed in kiosk mode: it's set as
/// the preferred home intent and whitelisted for lock task mode. Device setup
/// won't complete until the app is installed. After installation, users won't
/// be able to remove the app. You can only set this installType for one app
/// per policy. When this is present in the policy, status bar will be
/// automatically disabled.
core.String installType;
/// Whether the app is allowed to lock itself in full-screen mode. DEPRECATED.
/// Use InstallType KIOSK or kioskCustomLauncherEnabled to to configure a
/// dedicated device.
core.bool lockTaskAllowed;
/// Managed configuration applied to the app. The format for the configuration
/// is dictated by the ManagedProperty values supported by the app. Each field
/// name in the managed configuration must match the key field of the
/// ManagedProperty. The field value must be compatible with the type of the
/// ManagedProperty: *type* *JSON value* BOOL true or false STRING string
/// INTEGER number CHOICE string MULTISELECT array of strings HIDDEN string
/// BUNDLE_ARRAY array of objects
///
/// The values for Object must be JSON objects. It can consist of `num`,
/// `String`, `bool` and `null` as well as `Map` and `List` values.
core.Map<core.String, core.Object> managedConfiguration;
/// The managed configurations template for the app, saved from the managed
/// configurations iframe. This field is ignored if managed_configuration is
/// set.
ManagedConfigurationTemplate managedConfigurationTemplate;
/// The minimum version of the app that runs on the device. If set, the device
/// attempts to update the app to at least this version code. If the app is
/// not up-to-date, the device will contain a NonComplianceDetail with
/// non_compliance_reason set to APP_NOT_UPDATED. The app must already be
/// published to Google Play with a version code greater than or equal to this
/// value. At most 20 apps may specify a minimum version code per policy.
core.int minimumVersionCode;
/// The package name of the app. For example, com.google.android.youtube for
/// the YouTube app.
core.String packageName;
/// Explicit permission grants or denials for the app. These values override
/// the default_permission_policy and permission_grants which apply to all
/// apps.
core.List<PermissionGrant> permissionGrants;
ApplicationPolicy();
ApplicationPolicy.fromJson(core.Map _json) {
if (_json.containsKey('accessibleTrackIds')) {
accessibleTrackIds = (_json['accessibleTrackIds'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('connectedWorkAndPersonalApp')) {
connectedWorkAndPersonalApp =
_json['connectedWorkAndPersonalApp'] as core.String;
}
if (_json.containsKey('defaultPermissionPolicy')) {
defaultPermissionPolicy = _json['defaultPermissionPolicy'] as core.String;
}
if (_json.containsKey('delegatedScopes')) {
delegatedScopes = (_json['delegatedScopes'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('disabled')) {
disabled = _json['disabled'] as core.bool;
}
if (_json.containsKey('installType')) {
installType = _json['installType'] as core.String;
}
if (_json.containsKey('lockTaskAllowed')) {
lockTaskAllowed = _json['lockTaskAllowed'] as core.bool;
}
if (_json.containsKey('managedConfiguration')) {
managedConfiguration = (_json['managedConfiguration'] as core.Map)
.cast<core.String, core.Object>()
.map(
(key, item) => core.MapEntry(
key,
item as core.Object,
),
);
}
if (_json.containsKey('managedConfigurationTemplate')) {
managedConfigurationTemplate = ManagedConfigurationTemplate.fromJson(
_json['managedConfigurationTemplate']
as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('minimumVersionCode')) {
minimumVersionCode = _json['minimumVersionCode'] as core.int;
}
if (_json.containsKey('packageName')) {
packageName = _json['packageName'] as core.String;
}
if (_json.containsKey('permissionGrants')) {
permissionGrants = (_json['permissionGrants'] as core.List)
.map<PermissionGrant>((value) => PermissionGrant.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (accessibleTrackIds != null) {
_json['accessibleTrackIds'] = accessibleTrackIds;
}
if (connectedWorkAndPersonalApp != null) {
_json['connectedWorkAndPersonalApp'] = connectedWorkAndPersonalApp;
}
if (defaultPermissionPolicy != null) {
_json['defaultPermissionPolicy'] = defaultPermissionPolicy;
}
if (delegatedScopes != null) {
_json['delegatedScopes'] = delegatedScopes;
}
if (disabled != null) {
_json['disabled'] = disabled;
}
if (installType != null) {
_json['installType'] = installType;
}
if (lockTaskAllowed != null) {
_json['lockTaskAllowed'] = lockTaskAllowed;
}
if (managedConfiguration != null) {
_json['managedConfiguration'] = managedConfiguration;
}
if (managedConfigurationTemplate != null) {
_json['managedConfigurationTemplate'] =
managedConfigurationTemplate.toJson();
}
if (minimumVersionCode != null) {
_json['minimumVersionCode'] = minimumVersionCode;
}
if (packageName != null) {
_json['packageName'] = packageName;
}
if (permissionGrants != null) {
_json['permissionGrants'] =
permissionGrants.map((value) => value.toJson()).toList();
}
return _json;
}
}
/// Information reported about an installed app.
class ApplicationReport {
/// The source of the package.
/// Possible string values are:
/// - "APPLICATION_SOURCE_UNSPECIFIED" : The app was sideloaded from an
/// unspecified source.
/// - "SYSTEM_APP_FACTORY_VERSION" : This is a system app from the device's
/// factory image.
/// - "SYSTEM_APP_UPDATED_VERSION" : This is an updated system app.
/// - "INSTALLED_FROM_PLAY_STORE" : The app was installed from the Google Play
/// Store.
core.String applicationSource;
/// The display name of the app.
core.String displayName;
/// List of app events. The most recent 20 events are stored in the list.
core.List<ApplicationEvent> events;
/// The package name of the app that installed this app.
core.String installerPackageName;
/// List of keyed app states reported by the app.
core.List<KeyedAppState> keyedAppStates;
/// Package name of the app.
core.String packageName;
/// The SHA-256 hash of the app's APK file, which can be used to verify the
/// app hasn't been modified. Each byte of the hash value is represented as a
/// two-digit hexadecimal number.
core.String packageSha256Hash;
/// The SHA-1 hash of each android.content.pm.Signature
/// (https://developer.android.com/reference/android/content/pm/Signature.html)
/// associated with the app package. Each byte of each hash value is
/// represented as a two-digit hexadecimal number.
core.List<core.String> signingKeyCertFingerprints;
/// Application state.
/// Possible string values are:
/// - "APPLICATION_STATE_UNSPECIFIED" : App state is unspecified
/// - "REMOVED" : App was removed from the device
/// - "INSTALLED" : App is installed on the device
core.String state;
/// The app version code, which can be used to determine whether one version
/// is more recent than another.
core.int versionCode;
/// The app version as displayed to the user.
core.String versionName;
ApplicationReport();
ApplicationReport.fromJson(core.Map _json) {
if (_json.containsKey('applicationSource')) {
applicationSource = _json['applicationSource'] as core.String;
}
if (_json.containsKey('displayName')) {
displayName = _json['displayName'] as core.String;
}
if (_json.containsKey('events')) {
events = (_json['events'] as core.List)
.map<ApplicationEvent>((value) => ApplicationEvent.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('installerPackageName')) {
installerPackageName = _json['installerPackageName'] as core.String;
}
if (_json.containsKey('keyedAppStates')) {
keyedAppStates = (_json['keyedAppStates'] as core.List)
.map<KeyedAppState>((value) => KeyedAppState.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('packageName')) {
packageName = _json['packageName'] as core.String;
}
if (_json.containsKey('packageSha256Hash')) {
packageSha256Hash = _json['packageSha256Hash'] as core.String;
}
if (_json.containsKey('signingKeyCertFingerprints')) {
signingKeyCertFingerprints =
(_json['signingKeyCertFingerprints'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('state')) {
state = _json['state'] as core.String;
}
if (_json.containsKey('versionCode')) {
versionCode = _json['versionCode'] as core.int;
}
if (_json.containsKey('versionName')) {
versionName = _json['versionName'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (applicationSource != null) {
_json['applicationSource'] = applicationSource;
}
if (displayName != null) {
_json['displayName'] = displayName;
}
if (events != null) {
_json['events'] = events.map((value) => value.toJson()).toList();
}
if (installerPackageName != null) {
_json['installerPackageName'] = installerPackageName;
}
if (keyedAppStates != null) {
_json['keyedAppStates'] =
keyedAppStates.map((value) => value.toJson()).toList();
}
if (packageName != null) {
_json['packageName'] = packageName;
}
if (packageSha256Hash != null) {
_json['packageSha256Hash'] = packageSha256Hash;
}
if (signingKeyCertFingerprints != null) {
_json['signingKeyCertFingerprints'] = signingKeyCertFingerprints;
}
if (state != null) {
_json['state'] = state;
}
if (versionCode != null) {
_json['versionCode'] = versionCode;
}
if (versionName != null) {
_json['versionName'] = versionName;
}
return _json;
}
}
/// Settings controlling the behavior of application reports.
class ApplicationReportingSettings {
/// Whether removed apps are included in application reports.
core.bool includeRemovedApps;
ApplicationReportingSettings();
ApplicationReportingSettings.fromJson(core.Map _json) {
if (_json.containsKey('includeRemovedApps')) {
includeRemovedApps = _json['includeRemovedApps'] as core.bool;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (includeRemovedApps != null) {
_json['includeRemovedApps'] = includeRemovedApps;
}
return _json;
}
}
/// An action to block access to apps and data on a fully managed device or in a
/// work profile. This action also triggers a device or work profile to displays
/// a user-facing notification with information (where possible) on how to
/// correct the compliance issue. Note: wipeAction must also be specified.
class BlockAction {
/// Number of days the policy is non-compliant before the device or work
/// profile is blocked. To block access immediately, set to 0. blockAfterDays
/// must be less than wipeAfterDays.
core.int blockAfterDays;
/// Specifies the scope of this BlockAction. Only applicable to devices that
/// are company-owned.
/// Possible string values are:
/// - "BLOCK_SCOPE_UNSPECIFIED" : Unspecified. Defaults to
/// BLOCK_SCOPE_WORK_PROFILE.
/// - "BLOCK_SCOPE_WORK_PROFILE" : Block action is only applied to apps in the
/// work profile. Apps in the personal profile are unaffected.
/// - "BLOCK_SCOPE_DEVICE" : Block action is applied to the entire device,
/// including apps in the personal profile.
core.String blockScope;
BlockAction();
BlockAction.fromJson(core.Map _json) {
if (_json.containsKey('blockAfterDays')) {
blockAfterDays = _json['blockAfterDays'] as core.int;
}
if (_json.containsKey('blockScope')) {
blockScope = _json['blockScope'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (blockAfterDays != null) {
_json['blockAfterDays'] = blockAfterDays;
}
if (blockScope != null) {
_json['blockScope'] = blockScope;
}
return _json;
}
}
/// A rule for automatically choosing a private key and certificate to
/// authenticate the device to a server.
class ChoosePrivateKeyRule {
/// The package names for which outgoing requests are subject to this rule. If
/// no package names are specified, then the rule applies to all packages. For
/// each package name listed, the rule applies to that package and all other
/// packages that shared the same Android UID. The SHA256 hash of the signing
/// key signatures of each package_name will be verified against those
/// provided by Play
core.List<core.String> packageNames;
/// The alias of the private key to be used.
core.String privateKeyAlias;
/// The URL pattern to match against the URL of the outgoing request. The
/// pattern may contain asterisk (*) wildcards. Any URL is matched if
/// unspecified.
core.String urlPattern;
ChoosePrivateKeyRule();
ChoosePrivateKeyRule.fromJson(core.Map _json) {
if (_json.containsKey('packageNames')) {
packageNames = (_json['packageNames'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('privateKeyAlias')) {
privateKeyAlias = _json['privateKeyAlias'] as core.String;
}
if (_json.containsKey('urlPattern')) {
urlPattern = _json['urlPattern'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (packageNames != null) {
_json['packageNames'] = packageNames;
}
if (privateKeyAlias != null) {
_json['privateKeyAlias'] = privateKeyAlias;
}
if (urlPattern != null) {
_json['urlPattern'] = urlPattern;
}
return _json;
}
}
/// A command.
class Command {
/// The timestamp at which the command was created. The timestamp is
/// automatically generated by the server.
core.String createTime;
/// The duration for which the command is valid. The command will expire if
/// not executed by the device during this time. The default duration if
/// unspecified is ten minutes. There is no maximum duration.
core.String duration;
/// If the command failed, an error code explaining the failure. This is not
/// set when the command is cancelled by the caller.
/// Possible string values are:
/// - "COMMAND_ERROR_CODE_UNSPECIFIED" : There was no error.
/// - "UNKNOWN" : An unknown error occurred.
/// - "API_LEVEL" : The API level of the device does not support this command.
/// - "MANAGEMENT_MODE" : The management mode (profile owner, device owner,
/// etc.) does not support the command.
/// - "INVALID_VALUE" : The command has an invalid parameter value.
/// - "UNSUPPORTED" : The device doesn't support the command. Updating Android
/// Device Policy to the latest version may resolve the issue.
core.String errorCode;
/// For commands of type RESET_PASSWORD, optionally specifies the new
/// password.
core.String newPassword;
/// For commands of type RESET_PASSWORD, optionally specifies flags.
core.List<core.String> resetPasswordFlags;
/// The type of the command.
/// Possible string values are:
/// - "COMMAND_TYPE_UNSPECIFIED" : This value is disallowed.
/// - "LOCK" : Lock the device, as if the lock screen timeout had expired.
/// - "RESET_PASSWORD" : Reset the user's password.
/// - "REBOOT" : Reboot the device. Only supported on fully managed devices
/// running Android 7.0 (API level 24) or higher.
core.String type;
/// The resource name of the user that owns the device in the form
/// enterprises/{enterpriseId}/users/{userId}. This is automatically generated
/// by the server based on the device the command is sent to.
core.String userName;
Command();
Command.fromJson(core.Map _json) {
if (_json.containsKey('createTime')) {
createTime = _json['createTime'] as core.String;
}
if (_json.containsKey('duration')) {
duration = _json['duration'] as core.String;
}
if (_json.containsKey('errorCode')) {
errorCode = _json['errorCode'] as core.String;
}
if (_json.containsKey('newPassword')) {
newPassword = _json['newPassword'] as core.String;
}
if (_json.containsKey('resetPasswordFlags')) {
resetPasswordFlags = (_json['resetPasswordFlags'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('type')) {
type = _json['type'] as core.String;
}
if (_json.containsKey('userName')) {
userName = _json['userName'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (createTime != null) {
_json['createTime'] = createTime;
}
if (duration != null) {
_json['duration'] = duration;
}
if (errorCode != null) {
_json['errorCode'] = errorCode;
}
if (newPassword != null) {
_json['newPassword'] = newPassword;
}
if (resetPasswordFlags != null) {
_json['resetPasswordFlags'] = resetPasswordFlags;
}
if (type != null) {
_json['type'] = type;
}
if (userName != null) {
_json['userName'] = userName;
}
return _json;
}
}
/// A rule declaring which mitigating actions to take when a device is not
/// compliant with its policy. For every rule, there is always an implicit
/// mitigating action to set policy_compliant to false for the Device resource,
/// and display a message on the device indicating that the device is not
/// compliant with its policy. Other mitigating actions may optionally be taken
/// as well, depending on the field values in the rule.
class ComplianceRule {
/// A condition which is satisfied if the Android Framework API level on the
/// device doesn't meet a minimum requirement.
ApiLevelCondition apiLevelCondition;
/// If set to true, the rule includes a mitigating action to disable apps so
/// that the device is effectively disabled, but app data is preserved. If the
/// device is running an app in locked task mode, the app will be closed and a
/// UI showing the reason for non-compliance will be displayed.
core.bool disableApps;
/// A condition which is satisfied if there exists any matching
/// NonComplianceDetail for the device.
NonComplianceDetailCondition nonComplianceDetailCondition;
/// If set, the rule includes a mitigating action to disable apps specified in
/// the list, but app data is preserved.
core.List<core.String> packageNamesToDisable;
ComplianceRule();
ComplianceRule.fromJson(core.Map _json) {
if (_json.containsKey('apiLevelCondition')) {
apiLevelCondition = ApiLevelCondition.fromJson(
_json['apiLevelCondition'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('disableApps')) {
disableApps = _json['disableApps'] as core.bool;
}
if (_json.containsKey('nonComplianceDetailCondition')) {
nonComplianceDetailCondition = NonComplianceDetailCondition.fromJson(
_json['nonComplianceDetailCondition']
as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('packageNamesToDisable')) {
packageNamesToDisable = (_json['packageNamesToDisable'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (apiLevelCondition != null) {
_json['apiLevelCondition'] = apiLevelCondition.toJson();
}
if (disableApps != null) {
_json['disableApps'] = disableApps;
}
if (nonComplianceDetailCondition != null) {
_json['nonComplianceDetailCondition'] =
nonComplianceDetailCondition.toJson();
}
if (packageNamesToDisable != null) {
_json['packageNamesToDisable'] = packageNamesToDisable;
}
return _json;
}
}
/// Represents a whole or partial calendar date, e.g. a birthday. The time of
/// day and time zone are either specified elsewhere or are not significant. The
/// date is relative to the Proleptic Gregorian Calendar. This can represent: A
/// full date, with non-zero year, month and day values A month and day value,
/// with a zero year, e.g. an anniversary A year on its own, with zero month and
/// day values A year and month value, with a zero day, e.g. a credit card
/// expiration dateRelated types are google.type.TimeOfDay and
/// google.protobuf.Timestamp.
class Date {
/// Day of month. Must be from 1 to 31 and valid for the year and month, or 0
/// if specifying a year by itself or a year and month where the day is not
/// significant.
core.int day;
/// Month of year. Must be from 1 to 12, or 0 if specifying a year without a
/// month and day.
core.int month;
/// Year of date. Must be from 1 to 9999, or 0 if specifying a date without a
/// year.
core.int year;
Date();
Date.fromJson(core.Map _json) {
if (_json.containsKey('day')) {
day = _json['day'] as core.int;
}
if (_json.containsKey('month')) {
month = _json['month'] as core.int;
}
if (_json.containsKey('year')) {
year = _json['year'] as core.int;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (day != null) {
_json['day'] = day;
}
if (month != null) {
_json['month'] = month;
}
if (year != null) {
_json['year'] = year;
}
return _json;
}
}
/// A device owned by an enterprise. Unless otherwise noted, all fields are
/// read-only and can't be modified by enterprises.devices.patch.
class Device {
/// The API level of the Android platform version running on the device.
core.int apiLevel;
/// Reports for apps installed on the device. This information is only
/// available when application_reports_enabled is true in the device's policy.
core.List<ApplicationReport> applicationReports;
/// The name of the policy currently applied to the device.
core.String appliedPolicyName;
/// The version of the policy currently applied to the device.
core.String appliedPolicyVersion;
/// The state currently applied to the device.
/// Possible string values are:
/// - "DEVICE_STATE_UNSPECIFIED" : This value is disallowed.
/// - "ACTIVE" : The device is active.
/// - "DISABLED" : The device is disabled.
/// - "DELETED" : The device was deleted. This state will never be returned by
/// an API call, but is used in the final status report published to Cloud
/// Pub/Sub when the device acknowledges the deletion.
/// - "PROVISIONING" : The device is being provisioned. Newly enrolled devices
/// are in this state until they have a policy applied.
core.String appliedState;
/// Device settings information. This information is only available if
/// deviceSettingsEnabled is true in the device's policy.
DeviceSettings deviceSettings;
/// If the device state is DISABLED, an optional message that is displayed on
/// the device indicating the reason the device is disabled. This field can be
/// modified by a patch request.
UserFacingMessage disabledReason;
/// Detailed information about displays on the device. This information is
/// only available if displayInfoEnabled is true in the device's policy.
core.List<Display> displays;
/// The time of device enrollment.
core.String enrollmentTime;
/// If the device was enrolled with an enrollment token with additional data
/// provided, this field contains that data.
core.String enrollmentTokenData;
/// If the device was enrolled with an enrollment token, this field contains
/// the name of the token.
core.String enrollmentTokenName;
/// Detailed information about the device hardware.
HardwareInfo hardwareInfo;
/// Hardware status samples in chronological order. This information is only
/// available if hardwareStatusEnabled is true in the device's policy.
core.List<HardwareStatus> hardwareStatusSamples;
/// Deprecated.
core.String lastPolicyComplianceReportTime;
/// The last time the device fetched its policy.
core.String lastPolicySyncTime;
/// The last time the device sent a status report.
core.String lastStatusReportTime;
/// The type of management mode Android Device Policy takes on the device.
/// This influences which policy settings are supported.
/// Possible string values are:
/// - "MANAGEMENT_MODE_UNSPECIFIED" : This value is disallowed.
/// - "DEVICE_OWNER" : Device owner. Android Device Policy has full control
/// over the device.
/// - "PROFILE_OWNER" : Profile owner. Android Device Policy has control over
/// a managed profile on the device.
core.String managementMode;
/// Events related to memory and storage measurements in chronological order.
/// This information is only available if memoryInfoEnabled is true in the
/// device's policy.
core.List<MemoryEvent> memoryEvents;
/// Memory information. This information is only available if
/// memoryInfoEnabled is true in the device's policy.
MemoryInfo memoryInfo;
/// The name of the device in the form
/// enterprises/{enterpriseId}/devices/{deviceId}.
core.String name;
/// Device network information. This information is only available if
/// networkInfoEnabled is true in the device's policy.
NetworkInfo networkInfo;
/// Details about policy settings that the device is not compliant with.
core.List<NonComplianceDetail> nonComplianceDetails;
/// Ownership of the managed device.
/// Possible string values are:
/// - "OWNERSHIP_UNSPECIFIED" : Ownership is unspecified.
/// - "COMPANY_OWNED" : Device is company-owned.
/// - "PERSONALLY_OWNED" : Device is personally-owned.
core.String ownership;
/// Whether the device is compliant with its policy.
core.bool policyCompliant;
/// The name of the policy applied to the device, in the form
/// enterprises/{enterpriseId}/policies/{policyId}. If not specified, the
/// policy_name for the device's user is applied. This field can be modified
/// by a patch request. You can specify only the policyId when calling
/// enterprises.devices.patch, as long as the policyId doesn’t contain any
/// slashes. The rest of the policy name is inferred.
core.String policyName;
/// Power management events on the device in chronological order. This
/// information is only available if powerManagementEventsEnabled is true in
/// the device's policy.
core.List<PowerManagementEvent> powerManagementEvents;
/// If the same physical device has been enrolled multiple times, this field
/// contains its previous device names. The serial number is used as the
/// unique identifier to determine if the same physical device has enrolled
/// previously. The names are in chronological order.
core.List<core.String> previousDeviceNames;
/// Device's security posture value that reflects how secure the device is.
SecurityPosture securityPosture;
/// Detailed information about the device software. This information is only
/// available if softwareInfoEnabled is true in the device's policy.
SoftwareInfo softwareInfo;
/// The state to be applied to the device. This field can be modified by a
/// patch request. Note that when calling enterprises.devices.patch, ACTIVE
/// and DISABLED are the only allowable values. To enter the device into a
/// DELETED state, call enterprises.devices.delete.
/// Possible string values are:
/// - "DEVICE_STATE_UNSPECIFIED" : This value is disallowed.
/// - "ACTIVE" : The device is active.
/// - "DISABLED" : The device is disabled.
/// - "DELETED" : The device was deleted. This state will never be returned by
/// an API call, but is used in the final status report published to Cloud
/// Pub/Sub when the device acknowledges the deletion.
/// - "PROVISIONING" : The device is being provisioned. Newly enrolled devices
/// are in this state until they have a policy applied.
core.String state;
/// Map of selected system properties name and value related to the device.
/// This information is only available if systemPropertiesEnabled is true in
/// the device's policy.
core.Map<core.String, core.String> systemProperties;
/// The user who owns the device.
User user;
/// The resource name of the user that owns this device in the form
/// enterprises/{enterpriseId}/users/{userId}.
core.String userName;
Device();
Device.fromJson(core.Map _json) {
if (_json.containsKey('apiLevel')) {
apiLevel = _json['apiLevel'] as core.int;
}
if (_json.containsKey('applicationReports')) {
applicationReports = (_json['applicationReports'] as core.List)
.map<ApplicationReport>((value) => ApplicationReport.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('appliedPolicyName')) {
appliedPolicyName = _json['appliedPolicyName'] as core.String;
}
if (_json.containsKey('appliedPolicyVersion')) {
appliedPolicyVersion = _json['appliedPolicyVersion'] as core.String;
}
if (_json.containsKey('appliedState')) {
appliedState = _json['appliedState'] as core.String;
}
if (_json.containsKey('deviceSettings')) {
deviceSettings = DeviceSettings.fromJson(
_json['deviceSettings'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('disabledReason')) {
disabledReason = UserFacingMessage.fromJson(
_json['disabledReason'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('displays')) {
displays = (_json['displays'] as core.List)
.map<Display>((value) =>
Display.fromJson(value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('enrollmentTime')) {
enrollmentTime = _json['enrollmentTime'] as core.String;
}
if (_json.containsKey('enrollmentTokenData')) {
enrollmentTokenData = _json['enrollmentTokenData'] as core.String;
}
if (_json.containsKey('enrollmentTokenName')) {
enrollmentTokenName = _json['enrollmentTokenName'] as core.String;
}
if (_json.containsKey('hardwareInfo')) {
hardwareInfo = HardwareInfo.fromJson(
_json['hardwareInfo'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('hardwareStatusSamples')) {
hardwareStatusSamples = (_json['hardwareStatusSamples'] as core.List)
.map<HardwareStatus>((value) => HardwareStatus.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('lastPolicyComplianceReportTime')) {
lastPolicyComplianceReportTime =
_json['lastPolicyComplianceReportTime'] as core.String;
}
if (_json.containsKey('lastPolicySyncTime')) {
lastPolicySyncTime = _json['lastPolicySyncTime'] as core.String;
}
if (_json.containsKey('lastStatusReportTime')) {
lastStatusReportTime = _json['lastStatusReportTime'] as core.String;
}
if (_json.containsKey('managementMode')) {
managementMode = _json['managementMode'] as core.String;
}
if (_json.containsKey('memoryEvents')) {
memoryEvents = (_json['memoryEvents'] as core.List)
.map<MemoryEvent>((value) => MemoryEvent.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('memoryInfo')) {
memoryInfo = MemoryInfo.fromJson(
_json['memoryInfo'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('name')) {
name = _json['name'] as core.String;
}
if (_json.containsKey('networkInfo')) {
networkInfo = NetworkInfo.fromJson(
_json['networkInfo'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('nonComplianceDetails')) {
nonComplianceDetails = (_json['nonComplianceDetails'] as core.List)
.map<NonComplianceDetail>((value) => NonComplianceDetail.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('ownership')) {
ownership = _json['ownership'] as core.String;
}
if (_json.containsKey('policyCompliant')) {
policyCompliant = _json['policyCompliant'] as core.bool;
}
if (_json.containsKey('policyName')) {
policyName = _json['policyName'] as core.String;
}
if (_json.containsKey('powerManagementEvents')) {
powerManagementEvents = (_json['powerManagementEvents'] as core.List)
.map<PowerManagementEvent>((value) => PowerManagementEvent.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('previousDeviceNames')) {
previousDeviceNames = (_json['previousDeviceNames'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('securityPosture')) {
securityPosture = SecurityPosture.fromJson(
_json['securityPosture'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('softwareInfo')) {
softwareInfo = SoftwareInfo.fromJson(
_json['softwareInfo'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('state')) {
state = _json['state'] as core.String;
}
if (_json.containsKey('systemProperties')) {
systemProperties = (_json['systemProperties'] as core.Map)
.cast<core.String, core.String>()
.map(
(key, item) => core.MapEntry(
key,
item as core.String,
),
);
}
if (_json.containsKey('user')) {
user =
User.fromJson(_json['user'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('userName')) {
userName = _json['userName'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (apiLevel != null) {
_json['apiLevel'] = apiLevel;
}
if (applicationReports != null) {
_json['applicationReports'] =
applicationReports.map((value) => value.toJson()).toList();
}
if (appliedPolicyName != null) {
_json['appliedPolicyName'] = appliedPolicyName;
}
if (appliedPolicyVersion != null) {
_json['appliedPolicyVersion'] = appliedPolicyVersion;
}
if (appliedState != null) {
_json['appliedState'] = appliedState;
}
if (deviceSettings != null) {
_json['deviceSettings'] = deviceSettings.toJson();
}
if (disabledReason != null) {
_json['disabledReason'] = disabledReason.toJson();
}
if (displays != null) {
_json['displays'] = displays.map((value) => value.toJson()).toList();
}
if (enrollmentTime != null) {
_json['enrollmentTime'] = enrollmentTime;
}
if (enrollmentTokenData != null) {
_json['enrollmentTokenData'] = enrollmentTokenData;
}
if (enrollmentTokenName != null) {
_json['enrollmentTokenName'] = enrollmentTokenName;
}
if (hardwareInfo != null) {
_json['hardwareInfo'] = hardwareInfo.toJson();
}
if (hardwareStatusSamples != null) {
_json['hardwareStatusSamples'] =
hardwareStatusSamples.map((value) => value.toJson()).toList();
}
if (lastPolicyComplianceReportTime != null) {
_json['lastPolicyComplianceReportTime'] = lastPolicyComplianceReportTime;
}
if (lastPolicySyncTime != null) {
_json['lastPolicySyncTime'] = lastPolicySyncTime;
}
if (lastStatusReportTime != null) {
_json['lastStatusReportTime'] = lastStatusReportTime;
}
if (managementMode != null) {
_json['managementMode'] = managementMode;
}
if (memoryEvents != null) {
_json['memoryEvents'] =
memoryEvents.map((value) => value.toJson()).toList();
}
if (memoryInfo != null) {
_json['memoryInfo'] = memoryInfo.toJson();
}
if (name != null) {
_json['name'] = name;
}
if (networkInfo != null) {
_json['networkInfo'] = networkInfo.toJson();
}
if (nonComplianceDetails != null) {
_json['nonComplianceDetails'] =
nonComplianceDetails.map((value) => value.toJson()).toList();
}
if (ownership != null) {
_json['ownership'] = ownership;
}
if (policyCompliant != null) {
_json['policyCompliant'] = policyCompliant;
}
if (policyName != null) {
_json['policyName'] = policyName;
}
if (powerManagementEvents != null) {
_json['powerManagementEvents'] =
powerManagementEvents.map((value) => value.toJson()).toList();
}
if (previousDeviceNames != null) {
_json['previousDeviceNames'] = previousDeviceNames;
}
if (securityPosture != null) {
_json['securityPosture'] = securityPosture.toJson();
}
if (softwareInfo != null) {
_json['softwareInfo'] = softwareInfo.toJson();
}
if (state != null) {
_json['state'] = state;
}
if (systemProperties != null) {
_json['systemProperties'] = systemProperties;
}
if (user != null) {
_json['user'] = user.toJson();
}
if (userName != null) {
_json['userName'] = userName;
}
return _json;
}
}
/// Information about security related device settings on device.
class DeviceSettings {
/// Whether ADB (https://developer.android.com/studio/command-line/adb.html)
/// is enabled on the device.
core.bool adbEnabled;
/// Whether developer mode is enabled on the device.
core.bool developmentSettingsEnabled;
/// Encryption status from DevicePolicyManager.
/// Possible string values are:
/// - "ENCRYPTION_STATUS_UNSPECIFIED" : Unspecified. No device should have
/// this type.
/// - "UNSUPPORTED" : Encryption is not supported by the device.
/// - "INACTIVE" : Encryption is supported by the device, but is not currently
/// active.
/// - "ACTIVATING" : Encryption is not currently active, but is currently
/// being activated.
/// - "ACTIVE" : Encryption is active.
/// - "ACTIVE_DEFAULT_KEY" : Encryption is active, but an encryption key is
/// not set by the user.
/// - "ACTIVE_PER_USER" : Encryption is active, and the encryption key is tied
/// to the user profile.
core.String encryptionStatus;
/// Whether the device is secured with PIN/password.
core.bool isDeviceSecure;
/// Whether the storage encryption is enabled.
core.bool isEncrypted;
/// Whether installing apps from unknown sources is enabled.
core.bool unknownSourcesEnabled;
/// Whether Verify Apps (Google Play Protect
/// (https://support.google.com/googleplay/answer/2812853)) is enabled on the
/// device.
core.bool verifyAppsEnabled;
DeviceSettings();
DeviceSettings.fromJson(core.Map _json) {
if (_json.containsKey('adbEnabled')) {
adbEnabled = _json['adbEnabled'] as core.bool;
}
if (_json.containsKey('developmentSettingsEnabled')) {
developmentSettingsEnabled =
_json['developmentSettingsEnabled'] as core.bool;
}
if (_json.containsKey('encryptionStatus')) {
encryptionStatus = _json['encryptionStatus'] as core.String;
}
if (_json.containsKey('isDeviceSecure')) {
isDeviceSecure = _json['isDeviceSecure'] as core.bool;
}
if (_json.containsKey('isEncrypted')) {
isEncrypted = _json['isEncrypted'] as core.bool;
}
if (_json.containsKey('unknownSourcesEnabled')) {
unknownSourcesEnabled = _json['unknownSourcesEnabled'] as core.bool;
}
if (_json.containsKey('verifyAppsEnabled')) {
verifyAppsEnabled = _json['verifyAppsEnabled'] as core.bool;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (adbEnabled != null) {
_json['adbEnabled'] = adbEnabled;
}
if (developmentSettingsEnabled != null) {
_json['developmentSettingsEnabled'] = developmentSettingsEnabled;
}
if (encryptionStatus != null) {
_json['encryptionStatus'] = encryptionStatus;
}
if (isDeviceSecure != null) {
_json['isDeviceSecure'] = isDeviceSecure;
}
if (isEncrypted != null) {
_json['isEncrypted'] = isEncrypted;
}
if (unknownSourcesEnabled != null) {
_json['unknownSourcesEnabled'] = unknownSourcesEnabled;
}
if (verifyAppsEnabled != null) {
_json['verifyAppsEnabled'] = verifyAppsEnabled;
}
return _json;
}
}
/// Device display information.
class Display {
/// Display density expressed as dots-per-inch.
core.int density;
/// Unique display id.
core.int displayId;
/// Display height in pixels.
core.int height;
/// Name of the display.
core.String name;
/// Refresh rate of the display in frames per second.
core.int refreshRate;
/// State of the display.
/// Possible string values are:
/// - "DISPLAY_STATE_UNSPECIFIED" : This value is disallowed.
/// - "OFF" : Display is off.
/// - "ON" : Display is on.
/// - "DOZE" : Display is dozing in a low power state
/// - "SUSPENDED" : Display is dozing in a suspended low power state.
core.String state;
/// Display width in pixels.
core.int width;
Display();
Display.fromJson(core.Map _json) {
if (_json.containsKey('density')) {
density = _json['density'] as core.int;
}
if (_json.containsKey('displayId')) {
displayId = _json['displayId'] as core.int;
}
if (_json.containsKey('height')) {
height = _json['height'] as core.int;
}
if (_json.containsKey('name')) {
name = _json['name'] as core.String;
}
if (_json.containsKey('refreshRate')) {
refreshRate = _json['refreshRate'] as core.int;
}
if (_json.containsKey('state')) {
state = _json['state'] as core.String;
}
if (_json.containsKey('width')) {
width = _json['width'] as core.int;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (density != null) {
_json['density'] = density;
}
if (displayId != null) {
_json['displayId'] = displayId;
}
if (height != null) {
_json['height'] = height;
}
if (name != null) {
_json['name'] = name;
}
if (refreshRate != null) {
_json['refreshRate'] = refreshRate;
}
if (state != null) {
_json['state'] = state;
}
if (width != null) {
_json['width'] = width;
}
return _json;
}
}
/// A generic empty message that you can re-use to avoid defining duplicated
/// empty messages in your APIs. A typical example is to use it as the request
/// or the response type of an API method. For instance: service Foo { rpc
/// Bar(google.protobuf.Empty) returns (google.protobuf.Empty); } The JSON
/// representation for Empty is empty JSON object {}.
class Empty {
Empty();
Empty.fromJson(
// ignore: avoid_unused_constructor_parameters
core.Map _json);
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
return _json;
}
}
/// An enrollment token.
class EnrollmentToken {
/// Optional, arbitrary data associated with the enrollment token. This could
/// contain, for example, the ID of an org unit the device is assigned to
/// after enrollment. After a device enrolls with the token, this data will be
/// exposed in the enrollment_token_data field of the Device resource. The
/// data must be 1024 characters or less; otherwise, the creation request will
/// fail.
core.String additionalData;
/// Controls whether personal usage is allowed on a device provisioned with
/// this enrollment token.For company-owned devices: Enabling personal usage
/// allows the user to set up a work profile on the device. Disabling personal
/// usage requires the user provision the device as a fully managed device.For
/// personally-owned devices: Enabling personal usage allows the user to set
/// up a work profile on the device. Disabling personal usage will prevent the
/// device from provisioning. Personal usage cannot be disabled on
/// personally-owned device.
/// Possible string values are:
/// - "ALLOW_PERSONAL_USAGE_UNSPECIFIED" : Personal usage restriction is not
/// specified
/// - "PERSONAL_USAGE_ALLOWED" : Personal usage is allowed
/// - "PERSONAL_USAGE_DISALLOWED" : Personal usage is disallowed
core.String allowPersonalUsage;
/// The length of time the enrollment token is valid, ranging from 1 minute to
/// 30 days. If not specified, the default duration is 1 hour.
core.String duration;
/// The expiration time of the token. This is a read-only field generated by
/// the server.
core.String expirationTimestamp;
/// The name of the enrollment token, which is generated by the server during
/// creation, in the form
/// enterprises/{enterpriseId}/enrollmentTokens/{enrollmentTokenId}.
core.String name;
/// Whether the enrollment token is for one time use only. If the flag is set
/// to true, only one device can use it for registration.
core.bool oneTimeOnly;
/// The name of the policy initially applied to the enrolled device, in the
/// form enterprises/{enterpriseId}/policies/{policyId}. If not specified, the
/// policy_name for the device’s user is applied. If user_name is also not
/// specified, enterprises/{enterpriseId}/policies/default is applied by
/// default. When updating this field, you can specify only the policyId as
/// long as the policyId doesn’t contain any slashes. The rest of the policy
/// name will be inferred.
core.String policyName;
/// A JSON string whose UTF-8 representation can be used to generate a QR code
/// to enroll a device with this enrollment token. To enroll a device using
/// NFC, the NFC record must contain a serialized java.util.Properties
/// representation of the properties in the JSON.
core.String qrCode;
/// The user associated with this enrollment token. If it's specified when the
/// enrollment token is created and the user does not exist, the user will be
/// created. This field must not contain personally identifiable information.
/// Only the account_identifier field needs to be set.
User user;
/// The token value that's passed to the device and authorizes the device to
/// enroll. This is a read-only field generated by the server.
core.String value;
EnrollmentToken();
EnrollmentToken.fromJson(core.Map _json) {
if (_json.containsKey('additionalData')) {
additionalData = _json['additionalData'] as core.String;
}
if (_json.containsKey('allowPersonalUsage')) {
allowPersonalUsage = _json['allowPersonalUsage'] as core.String;
}
if (_json.containsKey('duration')) {
duration = _json['duration'] as core.String;
}
if (_json.containsKey('expirationTimestamp')) {
expirationTimestamp = _json['expirationTimestamp'] as core.String;
}
if (_json.containsKey('name')) {
name = _json['name'] as core.String;
}
if (_json.containsKey('oneTimeOnly')) {
oneTimeOnly = _json['oneTimeOnly'] as core.bool;
}
if (_json.containsKey('policyName')) {
policyName = _json['policyName'] as core.String;
}
if (_json.containsKey('qrCode')) {
qrCode = _json['qrCode'] as core.String;
}
if (_json.containsKey('user')) {
user =
User.fromJson(_json['user'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('value')) {
value = _json['value'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (additionalData != null) {
_json['additionalData'] = additionalData;
}
if (allowPersonalUsage != null) {
_json['allowPersonalUsage'] = allowPersonalUsage;
}
if (duration != null) {
_json['duration'] = duration;
}
if (expirationTimestamp != null) {
_json['expirationTimestamp'] = expirationTimestamp;
}
if (name != null) {
_json['name'] = name;
}
if (oneTimeOnly != null) {
_json['oneTimeOnly'] = oneTimeOnly;
}
if (policyName != null) {
_json['policyName'] = policyName;
}
if (qrCode != null) {
_json['qrCode'] = qrCode;
}
if (user != null) {
_json['user'] = user.toJson();
}
if (value != null) {
_json['value'] = value;
}
return _json;
}
}
/// The configuration applied to an enterprise.
class Enterprise {
/// Deprecated and unused.
core.bool appAutoApprovalEnabled;
/// The types of Google Pub/Sub notifications enabled for the enterprise.
core.List<core.String> enabledNotificationTypes;
/// The name of the enterprise displayed to users.
core.String enterpriseDisplayName;
/// An image displayed as a logo during device provisioning. Supported types
/// are: image/bmp, image/gif, image/x-ico, image/jpeg, image/png, image/webp,
/// image/vnd.wap.wbmp, image/x-adobe-dng.
ExternalData logo;
/// The name of the enterprise which is generated by the server during
/// creation, in the form enterprises/{enterpriseId}.
core.String name;
/// A color in RGB format that indicates the predominant color to display in
/// the device management app UI. The color components are stored as follows:
/// (red << 16) | (green << 8) | blue, where the value of each component is
/// between 0 and 255, inclusive.
core.int primaryColor;
/// The topic that Cloud Pub/Sub notifications are published to, in the form
/// projects/{project}/topics/{topic}. This field is only required if Pub/Sub
/// notifications are enabled.
core.String pubsubTopic;
/// Sign-in details of the enterprise.
core.List<SigninDetail> signinDetails;
/// Terms and conditions that must be accepted when provisioning a device for
/// this enterprise. A page of terms is generated for each value in this list.
core.List<TermsAndConditions> termsAndConditions;
Enterprise();
Enterprise.fromJson(core.Map _json) {
if (_json.containsKey('appAutoApprovalEnabled')) {
appAutoApprovalEnabled = _json['appAutoApprovalEnabled'] as core.bool;
}
if (_json.containsKey('enabledNotificationTypes')) {
enabledNotificationTypes =
(_json['enabledNotificationTypes'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('enterpriseDisplayName')) {
enterpriseDisplayName = _json['enterpriseDisplayName'] as core.String;
}
if (_json.containsKey('logo')) {
logo = ExternalData.fromJson(
_json['logo'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('name')) {
name = _json['name'] as core.String;
}
if (_json.containsKey('primaryColor')) {
primaryColor = _json['primaryColor'] as core.int;
}
if (_json.containsKey('pubsubTopic')) {
pubsubTopic = _json['pubsubTopic'] as core.String;
}
if (_json.containsKey('signinDetails')) {
signinDetails = (_json['signinDetails'] as core.List)
.map<SigninDetail>((value) => SigninDetail.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('termsAndConditions')) {
termsAndConditions = (_json['termsAndConditions'] as core.List)
.map<TermsAndConditions>((value) => TermsAndConditions.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (appAutoApprovalEnabled != null) {
_json['appAutoApprovalEnabled'] = appAutoApprovalEnabled;
}
if (enabledNotificationTypes != null) {
_json['enabledNotificationTypes'] = enabledNotificationTypes;
}
if (enterpriseDisplayName != null) {
_json['enterpriseDisplayName'] = enterpriseDisplayName;
}
if (logo != null) {
_json['logo'] = logo.toJson();
}
if (name != null) {
_json['name'] = name;
}
if (primaryColor != null) {
_json['primaryColor'] = primaryColor;
}
if (pubsubTopic != null) {
_json['pubsubTopic'] = pubsubTopic;
}
if (signinDetails != null) {
_json['signinDetails'] =
signinDetails.map((value) => value.toJson()).toList();
}
if (termsAndConditions != null) {
_json['termsAndConditions'] =
termsAndConditions.map((value) => value.toJson()).toList();
}
return _json;
}
}
/// Data hosted at an external location. The data is to be downloaded by Android
/// Device Policy and verified against the hash.
class ExternalData {
/// The base-64 encoded SHA-256 hash of the content hosted at url. If the
/// content doesn't match this hash, Android Device Policy won't use the data.
core.String sha256Hash;
/// The absolute URL to the data, which must use either the http or https
/// scheme. Android Device Policy doesn't provide any credentials in the GET
/// request, so the URL must be publicly accessible. Including a long, random
/// component in the URL may be used to prevent attackers from discovering the
/// URL.
core.String url;
ExternalData();
ExternalData.fromJson(core.Map _json) {
if (_json.containsKey('sha256Hash')) {
sha256Hash = _json['sha256Hash'] as core.String;
}
if (_json.containsKey('url')) {
url = _json['url'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (sha256Hash != null) {
_json['sha256Hash'] = sha256Hash;
}
if (url != null) {
_json['url'] = url;
}
return _json;
}
}
/// A system freeze period. When a device’s clock is within the freeze period,
/// all incoming system updates (including security patches) are blocked and
/// won’t be installed. When a device is outside the freeze period, normal
/// update behavior applies. Leap years are ignored in freeze period
/// calculations, in particular: * If Feb. 29th is set as the start or end date
/// of a freeze period, the freeze period will start or end on Feb. 28th
/// instead. * When a device’s system clock reads Feb. 29th, it’s treated as
/// Feb. 28th. * When calculating the number of days in a freeze period or the
/// time between two freeze periods, Feb. 29th is ignored and not counted as a
/// day.
class FreezePeriod {
/// The end date (inclusive) of the freeze period. Must be no later than 90
/// days from the start date. If the end date is earlier than the start date,
/// the freeze period is considered wrapping year-end. Note: year must not be
/// set. For example, {"month": 1,"date": 30}.
Date endDate;
/// The start date (inclusive) of the freeze period. Note: year must not be
/// set. For example, {"month": 1,"date": 30}.
Date startDate;
FreezePeriod();
FreezePeriod.fromJson(core.Map _json) {
if (_json.containsKey('endDate')) {
endDate = Date.fromJson(
_json['endDate'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('startDate')) {
startDate = Date.fromJson(
_json['startDate'] as core.Map<core.String, core.dynamic>);
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (endDate != null) {
_json['endDate'] = endDate.toJson();
}
if (startDate != null) {
_json['startDate'] = startDate.toJson();
}
return _json;
}
}
/// Information about device hardware. The fields related to temperature
/// thresholds are only available if hardwareStatusEnabled is true in the
/// device's policy.
class HardwareInfo {
/// Battery shutdown temperature thresholds in Celsius for each battery on the
/// device.
core.List<core.double> batteryShutdownTemperatures;
/// Battery throttling temperature thresholds in Celsius for each battery on
/// the device.
core.List<core.double> batteryThrottlingTemperatures;
/// Brand of the device. For example, Google.
core.String brand;
/// CPU shutdown temperature thresholds in Celsius for each CPU on the device.
core.List<core.double> cpuShutdownTemperatures;
/// CPU throttling temperature thresholds in Celsius for each CPU on the
/// device.
core.List<core.double> cpuThrottlingTemperatures;
/// Baseband version. For example, MDM9625_104662.22.05.34p.
core.String deviceBasebandVersion;
/// GPU shutdown temperature thresholds in Celsius for each GPU on the device.
core.List<core.double> gpuShutdownTemperatures;
/// GPU throttling temperature thresholds in Celsius for each GPU on the
/// device.
core.List<core.double> gpuThrottlingTemperatures;
/// Name of the hardware. For example, Angler.
core.String hardware;
/// Manufacturer. For example, Motorola.
core.String manufacturer;
/// The model of the device. For example, Asus Nexus 7.
core.String model;
/// The device serial number.
core.String serialNumber;
/// Device skin shutdown temperature thresholds in Celsius.
core.List<core.double> skinShutdownTemperatures;
/// Device skin throttling temperature thresholds in Celsius.
core.List<core.double> skinThrottlingTemperatures;
HardwareInfo();
HardwareInfo.fromJson(core.Map _json) {
if (_json.containsKey('batteryShutdownTemperatures')) {
batteryShutdownTemperatures =
(_json['batteryShutdownTemperatures'] as core.List)
.map<core.double>((value) => (value as core.num).toDouble())
.toList();
}
if (_json.containsKey('batteryThrottlingTemperatures')) {
batteryThrottlingTemperatures =
(_json['batteryThrottlingTemperatures'] as core.List)
.map<core.double>((value) => (value as core.num).toDouble())
.toList();
}
if (_json.containsKey('brand')) {
brand = _json['brand'] as core.String;
}
if (_json.containsKey('cpuShutdownTemperatures')) {
cpuShutdownTemperatures = (_json['cpuShutdownTemperatures'] as core.List)
.map<core.double>((value) => (value as core.num).toDouble())
.toList();
}
if (_json.containsKey('cpuThrottlingTemperatures')) {
cpuThrottlingTemperatures =
(_json['cpuThrottlingTemperatures'] as core.List)
.map<core.double>((value) => (value as core.num).toDouble())
.toList();
}
if (_json.containsKey('deviceBasebandVersion')) {
deviceBasebandVersion = _json['deviceBasebandVersion'] as core.String;
}
if (_json.containsKey('gpuShutdownTemperatures')) {
gpuShutdownTemperatures = (_json['gpuShutdownTemperatures'] as core.List)
.map<core.double>((value) => (value as core.num).toDouble())
.toList();
}
if (_json.containsKey('gpuThrottlingTemperatures')) {
gpuThrottlingTemperatures =
(_json['gpuThrottlingTemperatures'] as core.List)
.map<core.double>((value) => (value as core.num).toDouble())
.toList();
}
if (_json.containsKey('hardware')) {
hardware = _json['hardware'] as core.String;
}
if (_json.containsKey('manufacturer')) {
manufacturer = _json['manufacturer'] as core.String;
}
if (_json.containsKey('model')) {
model = _json['model'] as core.String;
}
if (_json.containsKey('serialNumber')) {
serialNumber = _json['serialNumber'] as core.String;
}
if (_json.containsKey('skinShutdownTemperatures')) {
skinShutdownTemperatures =
(_json['skinShutdownTemperatures'] as core.List)
.map<core.double>((value) => (value as core.num).toDouble())
.toList();
}
if (_json.containsKey('skinThrottlingTemperatures')) {
skinThrottlingTemperatures =
(_json['skinThrottlingTemperatures'] as core.List)
.map<core.double>((value) => (value as core.num).toDouble())
.toList();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (batteryShutdownTemperatures != null) {
_json['batteryShutdownTemperatures'] = batteryShutdownTemperatures;
}
if (batteryThrottlingTemperatures != null) {
_json['batteryThrottlingTemperatures'] = batteryThrottlingTemperatures;
}
if (brand != null) {
_json['brand'] = brand;
}
if (cpuShutdownTemperatures != null) {
_json['cpuShutdownTemperatures'] = cpuShutdownTemperatures;
}
if (cpuThrottlingTemperatures != null) {
_json['cpuThrottlingTemperatures'] = cpuThrottlingTemperatures;
}
if (deviceBasebandVersion != null) {
_json['deviceBasebandVersion'] = deviceBasebandVersion;
}
if (gpuShutdownTemperatures != null) {
_json['gpuShutdownTemperatures'] = gpuShutdownTemperatures;
}
if (gpuThrottlingTemperatures != null) {
_json['gpuThrottlingTemperatures'] = gpuThrottlingTemperatures;
}
if (hardware != null) {
_json['hardware'] = hardware;
}
if (manufacturer != null) {
_json['manufacturer'] = manufacturer;
}
if (model != null) {
_json['model'] = model;
}
if (serialNumber != null) {
_json['serialNumber'] = serialNumber;
}
if (skinShutdownTemperatures != null) {
_json['skinShutdownTemperatures'] = skinShutdownTemperatures;
}
if (skinThrottlingTemperatures != null) {
_json['skinThrottlingTemperatures'] = skinThrottlingTemperatures;
}
return _json;
}
}
/// Hardware status. Temperatures may be compared to the temperature thresholds
/// available in hardwareInfo to determine hardware health.
class HardwareStatus {
/// Current battery temperatures in Celsius for each battery on the device.
core.List<core.double> batteryTemperatures;
/// Current CPU temperatures in Celsius for each CPU on the device.
core.List<core.double> cpuTemperatures;
/// CPU usages in percentage for each core available on the device. Usage is 0
/// for each unplugged core. Empty array implies that CPU usage is not
/// supported in the system.
core.List<core.double> cpuUsages;
/// The time the measurements were taken.
core.String createTime;
/// Fan speeds in RPM for each fan on the device. Empty array means that there
/// are no fans or fan speed is not supported on the system.
core.List<core.double> fanSpeeds;
/// Current GPU temperatures in Celsius for each GPU on the device.
core.List<core.double> gpuTemperatures;
/// Current device skin temperatures in Celsius.
core.List<core.double> skinTemperatures;
HardwareStatus();
HardwareStatus.fromJson(core.Map _json) {
if (_json.containsKey('batteryTemperatures')) {
batteryTemperatures = (_json['batteryTemperatures'] as core.List)
.map<core.double>((value) => (value as core.num).toDouble())
.toList();
}
if (_json.containsKey('cpuTemperatures')) {
cpuTemperatures = (_json['cpuTemperatures'] as core.List)
.map<core.double>((value) => (value as core.num).toDouble())
.toList();
}
if (_json.containsKey('cpuUsages')) {
cpuUsages = (_json['cpuUsages'] as core.List)
.map<core.double>((value) => (value as core.num).toDouble())
.toList();
}
if (_json.containsKey('createTime')) {
createTime = _json['createTime'] as core.String;
}
if (_json.containsKey('fanSpeeds')) {
fanSpeeds = (_json['fanSpeeds'] as core.List)
.map<core.double>((value) => (value as core.num).toDouble())
.toList();
}
if (_json.containsKey('gpuTemperatures')) {
gpuTemperatures = (_json['gpuTemperatures'] as core.List)
.map<core.double>((value) => (value as core.num).toDouble())
.toList();
}
if (_json.containsKey('skinTemperatures')) {
skinTemperatures = (_json['skinTemperatures'] as core.List)
.map<core.double>((value) => (value as core.num).toDouble())
.toList();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (batteryTemperatures != null) {
_json['batteryTemperatures'] = batteryTemperatures;
}
if (cpuTemperatures != null) {
_json['cpuTemperatures'] = cpuTemperatures;
}
if (cpuUsages != null) {
_json['cpuUsages'] = cpuUsages;
}
if (createTime != null) {
_json['createTime'] = createTime;
}
if (fanSpeeds != null) {
_json['fanSpeeds'] = fanSpeeds;
}
if (gpuTemperatures != null) {
_json['gpuTemperatures'] = gpuTemperatures;
}
if (skinTemperatures != null) {
_json['skinTemperatures'] = skinTemperatures;
}
return _json;
}
}
/// Keyed app state reported by the app.
class KeyedAppState {
/// The creation time of the app state on the device.
core.String createTime;
/// Optionally, a machine-readable value to be read by the EMM. For example,
/// setting values that the admin can choose to query against in the EMM
/// console (e.g. “notify me if the battery_warning data < 10”).
core.String data;
/// The key for the app state. Acts as a point of reference for what the app
/// is providing state for. For example, when providing managed configuration
/// feedback, this key could be the managed configuration key.
core.String key;
/// The time the app state was most recently updated.
core.String lastUpdateTime;
/// Optionally, a free-form message string to explain the app state. If the
/// state was triggered by a particular value (e.g. a managed configuration
/// value), it should be included in the message.
core.String message;
/// The severity of the app state.
/// Possible string values are:
/// - "SEVERITY_UNSPECIFIED" : Unspecified severity level.
/// - "INFO" : Information severity level.
/// - "ERROR" : Error severity level. This should only be set for genuine
/// error conditions that a management organization needs to take action to
/// fix.
core.String severity;
KeyedAppState();
KeyedAppState.fromJson(core.Map _json) {
if (_json.containsKey('createTime')) {
createTime = _json['createTime'] as core.String;
}
if (_json.containsKey('data')) {
data = _json['data'] as core.String;
}
if (_json.containsKey('key')) {
key = _json['key'] as core.String;
}
if (_json.containsKey('lastUpdateTime')) {
lastUpdateTime = _json['lastUpdateTime'] as core.String;
}
if (_json.containsKey('message')) {
message = _json['message'] as core.String;
}
if (_json.containsKey('severity')) {
severity = _json['severity'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (createTime != null) {
_json['createTime'] = createTime;
}
if (data != null) {
_json['data'] = data;
}
if (key != null) {
_json['key'] = key;
}
if (lastUpdateTime != null) {
_json['lastUpdateTime'] = lastUpdateTime;
}
if (message != null) {
_json['message'] = message;
}
if (severity != null) {
_json['severity'] = severity;
}
return _json;
}
}
/// Settings controlling the behavior of a device in kiosk mode. To enable kiosk
/// mode, set kioskCustomLauncherEnabled to true or specify an app in the policy
/// with installType KIOSK.
class KioskCustomization {
/// Specifies whether the Settings app is allowed in kiosk mode.
/// Possible string values are:
/// - "DEVICE_SETTINGS_UNSPECIFIED" : Unspecified, defaults to
/// SETTINGS_ACCESS_ALLOWED.
/// - "SETTINGS_ACCESS_ALLOWED" : Access to the Settings app is allowed in
/// kiosk mode.
/// - "SETTINGS_ACCESS_BLOCKED" : Access to the Settings app is not allowed in
/// kiosk mode.
core.String deviceSettings;
/// Sets the behavior of a device in kiosk mode when a user presses and holds
/// (long-presses) the Power button.
/// Possible string values are:
/// - "POWER_BUTTON_ACTIONS_UNSPECIFIED" : Unspecified, defaults to
/// POWER_BUTTON_AVAILABLE.
/// - "POWER_BUTTON_AVAILABLE" : The power menu (e.g. Power off, Restart) is
/// shown when a user long-presses the Power button of a device in kiosk mode.
/// - "POWER_BUTTON_BLOCKED" : The power menu (e.g. Power off, Restart) is not
/// shown when a user long-presses the Power button of a device in kiosk mode.
/// Note: this may prevent users from turning off the device.
core.String powerButtonActions;
/// Specifies whether system info and notifications are disabled in kiosk
/// mode.
/// Possible string values are:
/// - "STATUS_BAR_UNSPECIFIED" : Unspecified, defaults to
/// INFO_AND_NOTIFICATIONS_DISABLED.
/// - "NOTIFICATIONS_AND_SYSTEM_INFO_ENABLED" : System info and notifications
/// are shown on the status bar in kiosk mode.Note: For this policy to take
/// effect, the device's home button must be enabled using
/// kioskCustomization.systemNavigation.
/// - "NOTIFICATIONS_AND_SYSTEM_INFO_DISABLED" : System info and notifications
/// are disabled in kiosk mode.
/// - "SYSTEM_INFO_ONLY" : Only system info is shown on the status bar.
core.String statusBar;
/// Specifies whether system error dialogs for crashed or unresponsive apps
/// are blocked in kiosk mode. When blocked, the system will force-stop the
/// app as if the user chooses the "close app" option on the UI.
/// Possible string values are:
/// - "SYSTEM_ERROR_WARNINGS_UNSPECIFIED" : Unspecified, defaults to
/// ERROR_AND_WARNINGS_MUTED.
/// - "ERROR_AND_WARNINGS_ENABLED" : All system error dialogs such as crash
/// and app not responding (ANR) are displayed.
/// - "ERROR_AND_WARNINGS_MUTED" : All system error dialogs, such as crash and
/// app not responding (ANR) are blocked. When blocked, the system force-stops
/// the app as if the user closes the app from the UI.
core.String systemErrorWarnings;
/// Specifies which navigation features are enabled (e.g. Home, Overview
/// buttons) in kiosk mode.
/// Possible string values are:
/// - "SYSTEM_NAVIGATION_UNSPECIFIED" : Unspecified, defaults to
/// NAVIGATION_DISABLED.
/// - "NAVIGATION_ENABLED" : Home and overview buttons are enabled.
/// - "NAVIGATION_DISABLED" : The home and Overview buttons are not
/// accessible.
/// - "HOME_BUTTON_ONLY" : Only the home button is enabled.
core.String systemNavigation;
KioskCustomization();
KioskCustomization.fromJson(core.Map _json) {
if (_json.containsKey('deviceSettings')) {
deviceSettings = _json['deviceSettings'] as core.String;
}
if (_json.containsKey('powerButtonActions')) {
powerButtonActions = _json['powerButtonActions'] as core.String;
}
if (_json.containsKey('statusBar')) {
statusBar = _json['statusBar'] as core.String;
}
if (_json.containsKey('systemErrorWarnings')) {
systemErrorWarnings = _json['systemErrorWarnings'] as core.String;
}
if (_json.containsKey('systemNavigation')) {
systemNavigation = _json['systemNavigation'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (deviceSettings != null) {
_json['deviceSettings'] = deviceSettings;
}
if (powerButtonActions != null) {
_json['powerButtonActions'] = powerButtonActions;
}
if (statusBar != null) {
_json['statusBar'] = statusBar;
}
if (systemErrorWarnings != null) {
_json['systemErrorWarnings'] = systemErrorWarnings;
}
if (systemNavigation != null) {
_json['systemNavigation'] = systemNavigation;
}
return _json;
}
}
/// An action to launch an app.
class LaunchAppAction {
/// Package name of app to be launched
core.String packageName;
LaunchAppAction();
LaunchAppAction.fromJson(core.Map _json) {
if (_json.containsKey('packageName')) {
packageName = _json['packageName'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (packageName != null) {
_json['packageName'] = packageName;
}
return _json;
}
}
/// Response to a request to list devices for a given enterprise.
class ListDevicesResponse {
/// The list of devices.
core.List<Device> devices;
/// If there are more results, a token to retrieve next page of results.
core.String nextPageToken;
ListDevicesResponse();
ListDevicesResponse.fromJson(core.Map _json) {
if (_json.containsKey('devices')) {
devices = (_json['devices'] as core.List)
.map<Device>((value) =>
Device.fromJson(value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('nextPageToken')) {
nextPageToken = _json['nextPageToken'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (devices != null) {
_json['devices'] = devices.map((value) => value.toJson()).toList();
}
if (nextPageToken != null) {
_json['nextPageToken'] = nextPageToken;
}
return _json;
}
}
/// The response message for Operations.ListOperations.
class ListOperationsResponse {
/// The standard List next-page token.
core.String nextPageToken;
/// A list of operations that matches the specified filter in the request.
core.List<Operation> operations;
ListOperationsResponse();
ListOperationsResponse.fromJson(core.Map _json) {
if (_json.containsKey('nextPageToken')) {
nextPageToken = _json['nextPageToken'] as core.String;
}
if (_json.containsKey('operations')) {
operations = (_json['operations'] as core.List)
.map<Operation>((value) =>
Operation.fromJson(value as core.Map<core.String, core.dynamic>))
.toList();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (nextPageToken != null) {
_json['nextPageToken'] = nextPageToken;
}
if (operations != null) {
_json['operations'] = operations.map((value) => value.toJson()).toList();
}
return _json;
}
}
/// Response to a request to list policies for a given enterprise.
class ListPoliciesResponse {
/// If there are more results, a token to retrieve next page of results.
core.String nextPageToken;
/// The list of policies.
core.List<Policy> policies;
ListPoliciesResponse();
ListPoliciesResponse.fromJson(core.Map _json) {
if (_json.containsKey('nextPageToken')) {
nextPageToken = _json['nextPageToken'] as core.String;
}
if (_json.containsKey('policies')) {
policies = (_json['policies'] as core.List)
.map<Policy>((value) =>
Policy.fromJson(value as core.Map<core.String, core.dynamic>))
.toList();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (nextPageToken != null) {
_json['nextPageToken'] = nextPageToken;
}
if (policies != null) {
_json['policies'] = policies.map((value) => value.toJson()).toList();
}
return _json;
}
}
/// Response to a request to list web apps for a given enterprise.
class ListWebAppsResponse {
/// If there are more results, a token to retrieve next page of results.
core.String nextPageToken;
/// The list of web apps.
core.List<WebApp> webApps;
ListWebAppsResponse();
ListWebAppsResponse.fromJson(core.Map _json) {
if (_json.containsKey('nextPageToken')) {
nextPageToken = _json['nextPageToken'] as core.String;
}
if (_json.containsKey('webApps')) {
webApps = (_json['webApps'] as core.List)
.map<WebApp>((value) =>
WebApp.fromJson(value as core.Map<core.String, core.dynamic>))
.toList();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (nextPageToken != null) {
_json['nextPageToken'] = nextPageToken;
}
if (webApps != null) {
_json['webApps'] = webApps.map((value) => value.toJson()).toList();
}
return _json;
}
}
/// The managed configurations template for the app, saved from the managed
/// configurations iframe.
class ManagedConfigurationTemplate {
/// Optional, a map containing configuration variables defined for the
/// configuration.
core.Map<core.String, core.String> configurationVariables;
/// The ID of the managed configurations template.
core.String templateId;
ManagedConfigurationTemplate();
ManagedConfigurationTemplate.fromJson(core.Map _json) {
if (_json.containsKey('configurationVariables')) {
configurationVariables = (_json['configurationVariables'] as core.Map)
.cast<core.String, core.String>()
.map(
(key, item) => core.MapEntry(
key,
item as core.String,
),
);
}
if (_json.containsKey('templateId')) {
templateId = _json['templateId'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (configurationVariables != null) {
_json['configurationVariables'] = configurationVariables;
}
if (templateId != null) {
_json['templateId'] = templateId;
}
return _json;
}
}
/// Managed property.
class ManagedProperty {
/// The default value of the property. BUNDLE_ARRAY properties don't have a
/// default value.
///
/// The values for Object must be JSON objects. It can consist of `num`,
/// `String`, `bool` and `null` as well as `Map` and `List` values.
core.Object defaultValue;
/// A longer description of the property, providing more detail of what it
/// affects. Localized.
core.String description;
/// For CHOICE or MULTISELECT properties, the list of possible entries.
core.List<ManagedPropertyEntry> entries;
/// The unique key that the app uses to identify the property, e.g.
/// "com.google.android.gm.fieldname".
core.String key;
/// For BUNDLE_ARRAY properties, the list of nested properties. A BUNDLE_ARRAY
/// property is at most two levels deep.
core.List<ManagedProperty> nestedProperties;
/// The name of the property. Localized.
core.String title;
/// The type of the property.
/// Possible string values are:
/// - "MANAGED_PROPERTY_TYPE_UNSPECIFIED" : Not used.
/// - "BOOL" : A property of boolean type.
/// - "STRING" : A property of string type.
/// - "INTEGER" : A property of integer type.
/// - "CHOICE" : A choice of one item from a set.
/// - "MULTISELECT" : A choice of multiple items from a set.
/// - "HIDDEN" : A hidden restriction of string type (the default value can be
/// used to pass along information that can't be modified, such as a version
/// code).
/// - "BUNDLE" : A bundle of properties
/// - "BUNDLE_ARRAY" : An array of property bundles.
core.String type;
ManagedProperty();
ManagedProperty.fromJson(core.Map _json) {
if (_json.containsKey('defaultValue')) {
defaultValue = _json['defaultValue'] as core.Object;
}
if (_json.containsKey('description')) {
description = _json['description'] as core.String;
}
if (_json.containsKey('entries')) {
entries = (_json['entries'] as core.List)
.map<ManagedPropertyEntry>((value) => ManagedPropertyEntry.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('key')) {
key = _json['key'] as core.String;
}
if (_json.containsKey('nestedProperties')) {
nestedProperties = (_json['nestedProperties'] as core.List)
.map<ManagedProperty>((value) => ManagedProperty.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('title')) {
title = _json['title'] as core.String;
}
if (_json.containsKey('type')) {
type = _json['type'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (defaultValue != null) {
_json['defaultValue'] = defaultValue;
}
if (description != null) {
_json['description'] = description;
}
if (entries != null) {
_json['entries'] = entries.map((value) => value.toJson()).toList();
}
if (key != null) {
_json['key'] = key;
}
if (nestedProperties != null) {
_json['nestedProperties'] =
nestedProperties.map((value) => value.toJson()).toList();
}
if (title != null) {
_json['title'] = title;
}
if (type != null) {
_json['type'] = type;
}
return _json;
}
}
/// An entry of a managed property.
class ManagedPropertyEntry {
/// The human-readable name of the value. Localized.
core.String name;
/// The machine-readable value of the entry, which should be used in the
/// configuration. Not localized.
core.String value;
ManagedPropertyEntry();
ManagedPropertyEntry.fromJson(core.Map _json) {
if (_json.containsKey('name')) {
name = _json['name'] as core.String;
}
if (_json.containsKey('value')) {
value = _json['value'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (name != null) {
_json['name'] = name;
}
if (value != null) {
_json['value'] = value;
}
return _json;
}
}
/// An event related to memory and storage measurements.
class MemoryEvent {
/// The number of free bytes in the medium, or for EXTERNAL_STORAGE_DETECTED,
/// the total capacity in bytes of the storage medium.
core.String byteCount;
/// The creation time of the event.
core.String createTime;
/// Event type.
/// Possible string values are:
/// - "MEMORY_EVENT_TYPE_UNSPECIFIED" : Unspecified. No events have this type.
/// - "RAM_MEASURED" : Free space in RAM was measured.
/// - "INTERNAL_STORAGE_MEASURED" : Free space in internal storage was
/// measured.
/// - "EXTERNAL_STORAGE_DETECTED" : A new external storage medium was
/// detected. The reported byte count is the total capacity of the storage
/// medium.
/// - "EXTERNAL_STORAGE_REMOVED" : An external storage medium was removed. The
/// reported byte count is zero.
/// - "EXTERNAL_STORAGE_MEASURED" : Free space in an external storage medium
/// was measured.
core.String eventType;
MemoryEvent();
MemoryEvent.fromJson(core.Map _json) {
if (_json.containsKey('byteCount')) {
byteCount = _json['byteCount'] as core.String;
}
if (_json.containsKey('createTime')) {
createTime = _json['createTime'] as core.String;
}
if (_json.containsKey('eventType')) {
eventType = _json['eventType'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (byteCount != null) {
_json['byteCount'] = byteCount;
}
if (createTime != null) {
_json['createTime'] = createTime;
}
if (eventType != null) {
_json['eventType'] = eventType;
}
return _json;
}
}
/// Information about device memory and storage.
class MemoryInfo {
/// Total internal storage on device in bytes.
core.String totalInternalStorage;
/// Total RAM on device in bytes.
core.String totalRam;
MemoryInfo();
MemoryInfo.fromJson(core.Map _json) {
if (_json.containsKey('totalInternalStorage')) {
totalInternalStorage = _json['totalInternalStorage'] as core.String;
}
if (_json.containsKey('totalRam')) {
totalRam = _json['totalRam'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (totalInternalStorage != null) {
_json['totalInternalStorage'] = totalInternalStorage;
}
if (totalRam != null) {
_json['totalRam'] = totalRam;
}
return _json;
}
}
/// Device network info.
class NetworkInfo {
/// IMEI number of the GSM device. For example, A1000031212.
core.String imei;
/// MEID number of the CDMA device. For example, A00000292788E1.
core.String meid;
/// Alphabetic name of current registered operator. For example, Vodafone.
core.String networkOperatorName;
/// Wi-Fi MAC address of the device. For example, 7c:11:11:11:11:11.
core.String wifiMacAddress;
NetworkInfo();
NetworkInfo.fromJson(core.Map _json) {
if (_json.containsKey('imei')) {
imei = _json['imei'] as core.String;
}
if (_json.containsKey('meid')) {
meid = _json['meid'] as core.String;
}
if (_json.containsKey('networkOperatorName')) {
networkOperatorName = _json['networkOperatorName'] as core.String;
}
if (_json.containsKey('wifiMacAddress')) {
wifiMacAddress = _json['wifiMacAddress'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (imei != null) {
_json['imei'] = imei;
}
if (meid != null) {
_json['meid'] = meid;
}
if (networkOperatorName != null) {
_json['networkOperatorName'] = networkOperatorName;
}
if (wifiMacAddress != null) {
_json['wifiMacAddress'] = wifiMacAddress;
}
return _json;
}
}
/// Provides detail about non-compliance with a policy setting.
class NonComplianceDetail {
/// If the policy setting could not be applied, the current value of the
/// setting on the device.
///
/// The values for Object must be JSON objects. It can consist of `num`,
/// `String`, `bool` and `null` as well as `Map` and `List` values.
core.Object currentValue;
/// For settings with nested fields, if a particular nested field is out of
/// compliance, this specifies the full path to the offending field. The path
/// is formatted in the same way the policy JSON field would be referenced in
/// JavaScript, that is: 1) For object-typed fields, the field name is
/// followed by a dot then by a subfield name. 2) For array-typed fields, the
/// field name is followed by the array index enclosed in brackets. For
/// example, to indicate a problem with the url field in the externalData
/// field in the 3rd application, the path would be
/// applications[2].externalData.url
core.String fieldPath;
/// If package_name is set and the non-compliance reason is APP_NOT_INSTALLED
/// or APP_NOT_UPDATED, the detailed reason the app can't be installed or
/// updated.
/// Possible string values are:
/// - "INSTALLATION_FAILURE_REASON_UNSPECIFIED" : This value is disallowed.
/// - "INSTALLATION_FAILURE_REASON_UNKNOWN" : An unknown condition is
/// preventing the app from being installed. Some potential reasons are that
/// the device doesn't have enough storage, the device network connection is
/// unreliable, or the installation is taking longer than expected. The
/// installation will be retried automatically.
/// - "IN_PROGRESS" : The installation is still in progress.
/// - "NOT_FOUND" : The app was not found in Play.
/// - "NOT_COMPATIBLE_WITH_DEVICE" : The app is incompatible with the device.
/// - "NOT_APPROVED" : The app has not been approved by the admin.
/// - "PERMISSIONS_NOT_ACCEPTED" : The app has new permissions that have not
/// been accepted by the admin.
/// - "NOT_AVAILABLE_IN_COUNTRY" : The app is not available in the user's
/// country.
/// - "NO_LICENSES_REMAINING" : There are no licenses available to assign to
/// the user.
/// - "NOT_ENROLLED" : The enterprise is no longer enrolled with Managed
/// Google Play or the admin has not accepted the latest Managed Google Play
/// Terms of Service.
/// - "USER_INVALID" : The user is no longer valid. The user may have been
/// deleted or disabled.
core.String installationFailureReason;
/// The reason the device is not in compliance with the setting.
/// Possible string values are:
/// - "NON_COMPLIANCE_REASON_UNSPECIFIED" : This value is disallowed.
/// - "API_LEVEL" : The setting is not supported in the API level of the
/// Android version running on the device.
/// - "MANAGEMENT_MODE" : The management mode (profile owner, device owner,
/// etc.) doesn't support the setting.
/// - "USER_ACTION" : The user has not taken required action to comply with
/// the setting.
/// - "INVALID_VALUE" : The setting has an invalid value.
/// - "APP_NOT_INSTALLED" : The app required to implement the policy is not
/// installed.
/// - "UNSUPPORTED" : The policy is not supported by the version of Android
/// Device Policy on the device.
/// - "APP_INSTALLED" : A blocked app is installed.
/// - "PENDING" : The setting hasn't been applied at the time of the report,
/// but is expected to be applied shortly.
/// - "APP_INCOMPATIBLE" : The setting can't be applied to the app because the
/// app doesn't support it, for example because its target SDK version is not
/// high enough.
/// - "APP_NOT_UPDATED" : The app is installed, but it hasn't been updated to
/// the minimum version code specified by policy.
core.String nonComplianceReason;
/// The package name indicating which app is out of compliance, if applicable.
core.String packageName;
/// The name of the policy setting. This is the JSON field name of a top-level
/// Policy field.
core.String settingName;
NonComplianceDetail();
NonComplianceDetail.fromJson(core.Map _json) {
if (_json.containsKey('currentValue')) {
currentValue = _json['currentValue'] as core.Object;
}
if (_json.containsKey('fieldPath')) {
fieldPath = _json['fieldPath'] as core.String;
}
if (_json.containsKey('installationFailureReason')) {
installationFailureReason =
_json['installationFailureReason'] as core.String;
}
if (_json.containsKey('nonComplianceReason')) {
nonComplianceReason = _json['nonComplianceReason'] as core.String;
}
if (_json.containsKey('packageName')) {
packageName = _json['packageName'] as core.String;
}
if (_json.containsKey('settingName')) {
settingName = _json['settingName'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (currentValue != null) {
_json['currentValue'] = currentValue;
}
if (fieldPath != null) {
_json['fieldPath'] = fieldPath;
}
if (installationFailureReason != null) {
_json['installationFailureReason'] = installationFailureReason;
}
if (nonComplianceReason != null) {
_json['nonComplianceReason'] = nonComplianceReason;
}
if (packageName != null) {
_json['packageName'] = packageName;
}
if (settingName != null) {
_json['settingName'] = settingName;
}
return _json;
}
}
/// A compliance rule condition which is satisfied if there exists any matching
/// NonComplianceDetail for the device. A NonComplianceDetail matches a
/// NonComplianceDetailCondition if all the fields which are set within the
/// NonComplianceDetailCondition match the corresponding NonComplianceDetail
/// fields.
class NonComplianceDetailCondition {
/// The reason the device is not in compliance with the setting. If not set,
/// then this condition matches any reason.
/// Possible string values are:
/// - "NON_COMPLIANCE_REASON_UNSPECIFIED" : This value is disallowed.
/// - "API_LEVEL" : The setting is not supported in the API level of the
/// Android version running on the device.
/// - "MANAGEMENT_MODE" : The management mode (profile owner, device owner,
/// etc.) doesn't support the setting.
/// - "USER_ACTION" : The user has not taken required action to comply with
/// the setting.
/// - "INVALID_VALUE" : The setting has an invalid value.
/// - "APP_NOT_INSTALLED" : The app required to implement the policy is not
/// installed.
/// - "UNSUPPORTED" : The policy is not supported by the version of Android
/// Device Policy on the device.
/// - "APP_INSTALLED" : A blocked app is installed.
/// - "PENDING" : The setting hasn't been applied at the time of the report,
/// but is expected to be applied shortly.
/// - "APP_INCOMPATIBLE" : The setting can't be applied to the app because the
/// app doesn't support it, for example because its target SDK version is not
/// high enough.
/// - "APP_NOT_UPDATED" : The app is installed, but it hasn't been updated to
/// the minimum version code specified by policy.
core.String nonComplianceReason;
/// The package name of the app that's out of compliance. If not set, then
/// this condition matches any package name.
core.String packageName;
/// The name of the policy setting. This is the JSON field name of a top-level
/// Policy field. If not set, then this condition matches any setting name.
core.String settingName;
NonComplianceDetailCondition();
NonComplianceDetailCondition.fromJson(core.Map _json) {
if (_json.containsKey('nonComplianceReason')) {
nonComplianceReason = _json['nonComplianceReason'] as core.String;
}
if (_json.containsKey('packageName')) {
packageName = _json['packageName'] as core.String;
}
if (_json.containsKey('settingName')) {
settingName = _json['settingName'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (nonComplianceReason != null) {
_json['nonComplianceReason'] = nonComplianceReason;
}
if (packageName != null) {
_json['packageName'] = packageName;
}
if (settingName != null) {
_json['settingName'] = settingName;
}
return _json;
}
}
/// This resource represents a long-running operation that is the result of a
/// network API call.
class Operation {
/// If the value is false, it means the operation is still in progress. If
/// true, the operation is completed, and either error or response is
/// available.
core.bool done;
/// The error result of the operation in case of failure or cancellation.
Status error;
/// Service-specific metadata associated with the operation. It typically
/// contains progress information and common metadata such as create time.
/// Some services might not provide such metadata. Any method that returns a
/// long-running operation should document the metadata type, if any.
///
/// The values for Object must be JSON objects. It can consist of `num`,
/// `String`, `bool` and `null` as well as `Map` and `List` values.
core.Map<core.String, core.Object> metadata;
/// The server-assigned name, which is only unique within the same service
/// that originally returns it. If you use the default HTTP mapping, the name
/// should be a resource name ending with operations/{unique_id}.
core.String name;
/// The normal response of the operation in case of success. If the original
/// method returns no data on success, such as Delete, the response is
/// google.protobuf.Empty. If the original method is standard
/// Get/Create/Update, the response should be the resource. For other methods,
/// the response should have the type XxxResponse, where Xxx is the original
/// method name. For example, if the original method name is TakeSnapshot(),
/// the inferred response type is TakeSnapshotResponse.
///
/// The values for Object must be JSON objects. It can consist of `num`,
/// `String`, `bool` and `null` as well as `Map` and `List` values.
core.Map<core.String, core.Object> response;
Operation();
Operation.fromJson(core.Map _json) {
if (_json.containsKey('done')) {
done = _json['done'] as core.bool;
}
if (_json.containsKey('error')) {
error = Status.fromJson(
_json['error'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('metadata')) {
metadata =
(_json['metadata'] as core.Map).cast<core.String, core.Object>().map(
(key, item) => core.MapEntry(
key,
item as core.Object,
),
);
}
if (_json.containsKey('name')) {
name = _json['name'] as core.String;
}
if (_json.containsKey('response')) {
response =
(_json['response'] as core.Map).cast<core.String, core.Object>().map(
(key, item) => core.MapEntry(
key,
item as core.Object,
),
);
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (done != null) {
_json['done'] = done;
}
if (error != null) {
_json['error'] = error.toJson();
}
if (metadata != null) {
_json['metadata'] = metadata;
}
if (name != null) {
_json['name'] = name;
}
if (response != null) {
_json['response'] = response;
}
return _json;
}
}
/// A list of package names.
class PackageNameList {
/// A list of package names.
core.List<core.String> packageNames;
PackageNameList();
PackageNameList.fromJson(core.Map _json) {
if (_json.containsKey('packageNames')) {
packageNames = (_json['packageNames'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (packageNames != null) {
_json['packageNames'] = packageNames;
}
return _json;
}
}
/// Requirements for the password used to unlock a device.
class PasswordRequirements {
/// Number of incorrect device-unlock passwords that can be entered before a
/// device is wiped. A value of 0 means there is no restriction.
core.int maximumFailedPasswordsForWipe;
/// Password expiration timeout.
core.String passwordExpirationTimeout;
/// The length of the password history. After setting this field, the user
/// won't be able to enter a new password that is the same as any password in
/// the history. A value of 0 means there is no restriction.
core.int passwordHistoryLength;
/// The minimum allowed password length. A value of 0 means there is no
/// restriction. Only enforced when password_quality is NUMERIC,
/// NUMERIC_COMPLEX, ALPHABETIC, ALPHANUMERIC, or COMPLEX.
core.int passwordMinimumLength;
/// Minimum number of letters required in the password. Only enforced when
/// password_quality is COMPLEX.
core.int passwordMinimumLetters;
/// Minimum number of lower case letters required in the password. Only
/// enforced when password_quality is COMPLEX.
core.int passwordMinimumLowerCase;
/// Minimum number of non-letter characters (numerical digits or symbols)
/// required in the password. Only enforced when password_quality is COMPLEX.
core.int passwordMinimumNonLetter;
/// Minimum number of numerical digits required in the password. Only enforced
/// when password_quality is COMPLEX.
core.int passwordMinimumNumeric;
/// Minimum number of symbols required in the password. Only enforced when
/// password_quality is COMPLEX.
core.int passwordMinimumSymbols;
/// Minimum number of upper case letters required in the password. Only
/// enforced when password_quality is COMPLEX.
core.int passwordMinimumUpperCase;
/// The required password quality.
/// Possible string values are:
/// - "PASSWORD_QUALITY_UNSPECIFIED" : There are no password requirements.
/// - "BIOMETRIC_WEAK" : The device must be secured with a low-security
/// biometric recognition technology, at minimum. This includes technologies
/// that can recognize the identity of an individual that are roughly
/// equivalent to a 3-digit PIN (false detection is less than 1 in 1,000).
/// - "SOMETHING" : A password is required, but there are no restrictions on
/// what the password must contain.
/// - "NUMERIC" : The password must contain numeric characters.
/// - "NUMERIC_COMPLEX" : The password must contain numeric characters with no
/// repeating (4444) or ordered (1234, 4321, 2468) sequences.
/// - "ALPHABETIC" : The password must contain alphabetic (or symbol)
/// characters.
/// - "ALPHANUMERIC" : The password must contain both numeric and alphabetic
/// (or symbol) characters.
/// - "COMPLEX" : The password must meet the minimum requirements specified in
/// passwordMinimumLength, passwordMinimumLetters, passwordMinimumSymbols,
/// etc. For example, if passwordMinimumSymbols is 2, the password must
/// contain at least two symbols.
core.String passwordQuality;
/// The scope that the password requirement applies to.
/// Possible string values are:
/// - "SCOPE_UNSPECIFIED" : The scope is unspecified. The password
/// requirements are applied to the work profile for work profile devices and
/// the whole device for fully managed or dedicated devices.
/// - "SCOPE_DEVICE" : The password requirements are only applied to the
/// device.
/// - "SCOPE_PROFILE" : The password requirements are only applied to the work
/// profile.
core.String passwordScope;
/// The length of time after a device or work profile is unlocked using a
/// strong form of authentication (password, PIN, pattern) that it can be
/// unlocked using any other authentication method (e.g. fingerprint, trust
/// agents, face). After the specified time period elapses, only strong forms
/// of authentication can be used to unlock the device or work profile.
/// Possible string values are:
/// - "REQUIRE_PASSWORD_UNLOCK_UNSPECIFIED" : Unspecified. Defaults to
/// USE_DEFAULT_DEVICE_TIMEOUT.
/// - "USE_DEFAULT_DEVICE_TIMEOUT" : The timeout period is set to the device’s
/// default.
/// - "REQUIRE_EVERY_DAY" : The timeout period is set to 24 hours.
core.String requirePasswordUnlock;
PasswordRequirements();
PasswordRequirements.fromJson(core.Map _json) {
if (_json.containsKey('maximumFailedPasswordsForWipe')) {
maximumFailedPasswordsForWipe =
_json['maximumFailedPasswordsForWipe'] as core.int;
}
if (_json.containsKey('passwordExpirationTimeout')) {
passwordExpirationTimeout =
_json['passwordExpirationTimeout'] as core.String;
}
if (_json.containsKey('passwordHistoryLength')) {
passwordHistoryLength = _json['passwordHistoryLength'] as core.int;
}
if (_json.containsKey('passwordMinimumLength')) {
passwordMinimumLength = _json['passwordMinimumLength'] as core.int;
}
if (_json.containsKey('passwordMinimumLetters')) {
passwordMinimumLetters = _json['passwordMinimumLetters'] as core.int;
}
if (_json.containsKey('passwordMinimumLowerCase')) {
passwordMinimumLowerCase = _json['passwordMinimumLowerCase'] as core.int;
}
if (_json.containsKey('passwordMinimumNonLetter')) {
passwordMinimumNonLetter = _json['passwordMinimumNonLetter'] as core.int;
}
if (_json.containsKey('passwordMinimumNumeric')) {
passwordMinimumNumeric = _json['passwordMinimumNumeric'] as core.int;
}
if (_json.containsKey('passwordMinimumSymbols')) {
passwordMinimumSymbols = _json['passwordMinimumSymbols'] as core.int;
}
if (_json.containsKey('passwordMinimumUpperCase')) {
passwordMinimumUpperCase = _json['passwordMinimumUpperCase'] as core.int;
}
if (_json.containsKey('passwordQuality')) {
passwordQuality = _json['passwordQuality'] as core.String;
}
if (_json.containsKey('passwordScope')) {
passwordScope = _json['passwordScope'] as core.String;
}
if (_json.containsKey('requirePasswordUnlock')) {
requirePasswordUnlock = _json['requirePasswordUnlock'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (maximumFailedPasswordsForWipe != null) {
_json['maximumFailedPasswordsForWipe'] = maximumFailedPasswordsForWipe;
}
if (passwordExpirationTimeout != null) {
_json['passwordExpirationTimeout'] = passwordExpirationTimeout;
}
if (passwordHistoryLength != null) {
_json['passwordHistoryLength'] = passwordHistoryLength;
}
if (passwordMinimumLength != null) {
_json['passwordMinimumLength'] = passwordMinimumLength;
}
if (passwordMinimumLetters != null) {
_json['passwordMinimumLetters'] = passwordMinimumLetters;
}
if (passwordMinimumLowerCase != null) {
_json['passwordMinimumLowerCase'] = passwordMinimumLowerCase;
}
if (passwordMinimumNonLetter != null) {
_json['passwordMinimumNonLetter'] = passwordMinimumNonLetter;
}
if (passwordMinimumNumeric != null) {
_json['passwordMinimumNumeric'] = passwordMinimumNumeric;
}
if (passwordMinimumSymbols != null) {
_json['passwordMinimumSymbols'] = passwordMinimumSymbols;
}
if (passwordMinimumUpperCase != null) {
_json['passwordMinimumUpperCase'] = passwordMinimumUpperCase;
}
if (passwordQuality != null) {
_json['passwordQuality'] = passwordQuality;
}
if (passwordScope != null) {
_json['passwordScope'] = passwordScope;
}
if (requirePasswordUnlock != null) {
_json['requirePasswordUnlock'] = requirePasswordUnlock;
}
return _json;
}
}
/// Configuration for an Android permission and its grant state.
class PermissionGrant {
/// The Android permission or group, e.g. android.permission.READ_CALENDAR or
/// android.permission_group.CALENDAR.
core.String permission;
/// The policy for granting the permission.
/// Possible string values are:
/// - "PERMISSION_POLICY_UNSPECIFIED" : Policy not specified. If no policy is
/// specified for a permission at any level, then the PROMPT behavior is used
/// by default.
/// - "PROMPT" : Prompt the user to grant a permission.
/// - "GRANT" : Automatically grant a permission.
/// - "DENY" : Automatically deny a permission.
core.String policy;
PermissionGrant();
PermissionGrant.fromJson(core.Map _json) {
if (_json.containsKey('permission')) {
permission = _json['permission'] as core.String;
}
if (_json.containsKey('policy')) {
policy = _json['policy'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (permission != null) {
_json['permission'] = permission;
}
if (policy != null) {
_json['policy'] = policy;
}
return _json;
}
}
/// A default activity for handling intents that match a particular intent
/// filter. Note: To set up a kiosk, use InstallType to KIOSK rather than use
/// persistent preferred activities.
class PersistentPreferredActivity {
/// The intent actions to match in the filter. If any actions are included in
/// the filter, then an intent's action must be one of those values for it to
/// match. If no actions are included, the intent action is ignored.
core.List<core.String> actions;
/// The intent categories to match in the filter. An intent includes the
/// categories that it requires, all of which must be included in the filter
/// in order to match. In other words, adding a category to the filter has no
/// impact on matching unless that category is specified in the intent.
core.List<core.String> categories;
/// The activity that should be the default intent handler. This should be an
/// Android component name, e.g. com.android.enterprise.app/.MainActivity.
/// Alternatively, the value may be the package name of an app, which causes
/// Android Device Policy to choose an appropriate activity from the app to
/// handle the intent.
core.String receiverActivity;
PersistentPreferredActivity();
PersistentPreferredActivity.fromJson(core.Map _json) {
if (_json.containsKey('actions')) {
actions = (_json['actions'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('categories')) {
categories = (_json['categories'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('receiverActivity')) {
receiverActivity = _json['receiverActivity'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (actions != null) {
_json['actions'] = actions;
}
if (categories != null) {
_json['categories'] = categories;
}
if (receiverActivity != null) {
_json['receiverActivity'] = receiverActivity;
}
return _json;
}
}
/// Policies for apps in the personal profile of a company-owned device with a
/// work profile.
class PersonalApplicationPolicy {
/// The type of installation to perform.
/// Possible string values are:
/// - "INSTALL_TYPE_UNSPECIFIED" : Unspecified. The default behavior is that
/// all installs are allowed.
/// - "BLOCKED" : The app is blocked and can't be installed in the personal
/// profile.
core.String installType;
/// The package name of the application.
core.String packageName;
PersonalApplicationPolicy();
PersonalApplicationPolicy.fromJson(core.Map _json) {
if (_json.containsKey('installType')) {
installType = _json['installType'] as core.String;
}
if (_json.containsKey('packageName')) {
packageName = _json['packageName'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (installType != null) {
_json['installType'] = installType;
}
if (packageName != null) {
_json['packageName'] = packageName;
}
return _json;
}
}
/// Policies controlling personal usage on a company-owned device with a work
/// profile.
class PersonalUsagePolicies {
/// Account types that can't be managed by the user.
core.List<core.String> accountTypesWithManagementDisabled;
/// Whether camera is disabled.
core.bool cameraDisabled;
/// Controls how long the work profile can stay off.
core.int maxDaysWithWorkOff;
/// Policy applied to applications in the personal profile.
core.List<PersonalApplicationPolicy> personalApplications;
/// Used together with personal_applications to control how apps in the
/// personal profile are allowed or blocked.
/// Possible string values are:
/// - "PLAY_STORE_MODE_UNSPECIFIED" : Unspecified. Default behavior is to
/// allow all installs.
/// - "BLACKLIST" : All Play Store apps are available, except those whose
/// install_type is BLOCKED in personal_applications.
core.String personalPlayStoreMode;
/// Whether screen capture is disabled.
core.bool screenCaptureDisabled;
PersonalUsagePolicies();
PersonalUsagePolicies.fromJson(core.Map _json) {
if (_json.containsKey('accountTypesWithManagementDisabled')) {
accountTypesWithManagementDisabled =
(_json['accountTypesWithManagementDisabled'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('cameraDisabled')) {
cameraDisabled = _json['cameraDisabled'] as core.bool;
}
if (_json.containsKey('maxDaysWithWorkOff')) {
maxDaysWithWorkOff = _json['maxDaysWithWorkOff'] as core.int;
}
if (_json.containsKey('personalApplications')) {
personalApplications = (_json['personalApplications'] as core.List)
.map<PersonalApplicationPolicy>((value) =>
PersonalApplicationPolicy.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('personalPlayStoreMode')) {
personalPlayStoreMode = _json['personalPlayStoreMode'] as core.String;
}
if (_json.containsKey('screenCaptureDisabled')) {
screenCaptureDisabled = _json['screenCaptureDisabled'] as core.bool;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (accountTypesWithManagementDisabled != null) {
_json['accountTypesWithManagementDisabled'] =
accountTypesWithManagementDisabled;
}
if (cameraDisabled != null) {
_json['cameraDisabled'] = cameraDisabled;
}
if (maxDaysWithWorkOff != null) {
_json['maxDaysWithWorkOff'] = maxDaysWithWorkOff;
}
if (personalApplications != null) {
_json['personalApplications'] =
personalApplications.map((value) => value.toJson()).toList();
}
if (personalPlayStoreMode != null) {
_json['personalPlayStoreMode'] = personalPlayStoreMode;
}
if (screenCaptureDisabled != null) {
_json['screenCaptureDisabled'] = screenCaptureDisabled;
}
return _json;
}
}
/// A policy resource represents a group of settings that govern the behavior of
/// a managed device and the apps installed on it.
class Policy {
/// Account types that can't be managed by the user.
core.List<core.String> accountTypesWithManagementDisabled;
/// Whether adding new users and profiles is disabled.
core.bool addUserDisabled;
/// Whether adjusting the master volume is disabled.
core.bool adjustVolumeDisabled;
/// Security policies set to the most secure values by default. To maintain
/// the security posture of a device, we don't recommend overriding any of the
/// default values.
AdvancedSecurityOverrides advancedSecurityOverrides;
/// Configuration for an always-on VPN connection. Use with
/// vpn_config_disabled to prevent modification of this setting.
AlwaysOnVpnPackage alwaysOnVpnPackage;
/// The app tracks for Android Device Policy the device can access. The device
/// receives the latest version among all accessible tracks. If no tracks are
/// specified, then the device only uses the production track.
core.List<core.String> androidDevicePolicyTracks;
/// The app auto update policy, which controls when automatic app updates can
/// be applied.
/// Possible string values are:
/// - "APP_AUTO_UPDATE_POLICY_UNSPECIFIED" : The auto-update policy is not
/// set. Equivalent to CHOICE_TO_THE_USER.
/// - "CHOICE_TO_THE_USER" : The user can control auto-updates.
/// - "NEVER" : Apps are never auto-updated.
/// - "WIFI_ONLY" : Apps are auto-updated over Wi-Fi only.
/// - "ALWAYS" : Apps are auto-updated at any time. Data charges may apply.
core.String appAutoUpdatePolicy;
/// Policy applied to apps.
core.List<ApplicationPolicy> applications;
/// Whether auto time is required, which prevents the user from manually
/// setting the date and time.
core.bool autoTimeRequired;
/// Whether applications other than the ones configured in applications are
/// blocked from being installed. When set, applications that were installed
/// under a previous policy but no longer appear in the policy are
/// automatically uninstalled.
core.bool blockApplicationsEnabled;
/// Whether configuring bluetooth is disabled.
core.bool bluetoothConfigDisabled;
/// Whether bluetooth contact sharing is disabled.
core.bool bluetoothContactSharingDisabled;
/// Whether bluetooth is disabled. Prefer this setting over
/// bluetooth_config_disabled because bluetooth_config_disabled can be
/// bypassed by the user.
core.bool bluetoothDisabled;
/// Whether all cameras on the device are disabled.
core.bool cameraDisabled;
/// Whether configuring cell broadcast is disabled.
core.bool cellBroadcastsConfigDisabled;
/// Rules for automatically choosing a private key and certificate to
/// authenticate the device to a server. The rules are ordered by increasing
/// precedence, so if an outgoing request matches more than one rule, the last
/// rule defines which private key to use.
core.List<ChoosePrivateKeyRule> choosePrivateKeyRules;
/// Rules declaring which mitigating actions to take when a device is not
/// compliant with its policy. When the conditions for multiple rules are
/// satisfied, all of the mitigating actions for the rules are taken. There is
/// a maximum limit of 100 rules. Use policy enforcement rules instead.
core.List<ComplianceRule> complianceRules;
/// Whether creating windows besides app windows is disabled.
core.bool createWindowsDisabled;
/// Whether configuring user credentials is disabled.
core.bool credentialsConfigDisabled;
/// Whether roaming data services are disabled.
core.bool dataRoamingDisabled;
/// Whether the user is allowed to enable debugging features.
core.bool debuggingFeaturesAllowed;
/// The default permission policy for runtime permission requests.
/// Possible string values are:
/// - "PERMISSION_POLICY_UNSPECIFIED" : Policy not specified. If no policy is
/// specified for a permission at any level, then the PROMPT behavior is used
/// by default.
/// - "PROMPT" : Prompt the user to grant a permission.
/// - "GRANT" : Automatically grant a permission.
/// - "DENY" : Automatically deny a permission.
core.String defaultPermissionPolicy;
/// The device owner information to be shown on the lock screen.
UserFacingMessage deviceOwnerLockScreenInfo;
/// Whether encryption is enabled
/// Possible string values are:
/// - "ENCRYPTION_POLICY_UNSPECIFIED" : This value is ignored, i.e. no
/// encryption required
/// - "ENABLED_WITHOUT_PASSWORD" : Encryption required but no password
/// required to boot
/// - "ENABLED_WITH_PASSWORD" : Encryption required with password required to
/// boot
core.String encryptionPolicy;
/// Whether app verification is force-enabled.
core.bool ensureVerifyAppsEnabled;
/// Whether factory resetting from settings is disabled.
core.bool factoryResetDisabled;
/// Email addresses of device administrators for factory reset protection.
/// When the device is factory reset, it will require one of these admins to
/// log in with the Google account email and password to unlock the device. If
/// no admins are specified, the device won't provide factory reset
/// protection.
core.List<core.String> frpAdminEmails;
/// Whether the user is allowed to have fun. Controls whether the Easter egg
/// game in Settings is disabled.
core.bool funDisabled;
/// Whether user installation of apps is disabled.
core.bool installAppsDisabled;
/// Whether the user is allowed to enable the "Unknown Sources" setting, which
/// allows installation of apps from unknown sources.
core.bool installUnknownSourcesAllowed;
/// Whether the keyguard is disabled.
core.bool keyguardDisabled;
/// Disabled keyguard customizations, such as widgets.
core.List<core.String> keyguardDisabledFeatures;
/// Whether the kiosk custom launcher is enabled. This replaces the home
/// screen with a launcher that locks down the device to the apps installed
/// via the applications setting. Apps appear on a single page in alphabetical
/// order. Use kioskCustomization to further configure the kiosk device
/// behavior.
core.bool kioskCustomLauncherEnabled;
/// Settings controlling the behavior of a device in kiosk mode. To enable
/// kiosk mode, set kioskCustomLauncherEnabled to true or specify an app in
/// the policy with installType KIOSK.
KioskCustomization kioskCustomization;
/// The degree of location detection enabled. The user may change the value
/// unless the user is otherwise blocked from accessing device settings.
/// Possible string values are:
/// - "LOCATION_MODE_UNSPECIFIED" : The current device value is not modified.
/// - "HIGH_ACCURACY" : All location detection methods are enabled, including
/// GPS, networks, and other sensors.
/// - "SENSORS_ONLY" : Only GPS and other sensors are enabled.
/// - "BATTERY_SAVING" : Only the network location provider is enabled.
/// - "OFF" : Location detection is disabled.
core.String locationMode;
/// A message displayed to the user in the device administators settings
/// screen.
UserFacingMessage longSupportMessage;
/// Maximum time in milliseconds for user activity until the device locks. A
/// value of 0 means there is no restriction.
core.String maximumTimeToLock;
/// The minimum allowed Android API level.
core.int minimumApiLevel;
/// Whether configuring mobile networks is disabled.
core.bool mobileNetworksConfigDisabled;
/// Whether adding or removing accounts is disabled.
core.bool modifyAccountsDisabled;
/// Whether the user mounting physical external media is disabled.
core.bool mountPhysicalMediaDisabled;
/// The name of the policy in the form
/// enterprises/{enterpriseId}/policies/{policyId}.
core.String name;
/// Whether the network escape hatch is enabled. If a network connection can't
/// be made at boot time, the escape hatch prompts the user to temporarily
/// connect to a network in order to refresh the device policy. After applying
/// policy, the temporary network will be forgotten and the device will
/// continue booting. This prevents being unable to connect to a network if
/// there is no suitable network in the last policy and the device boots into
/// an app in lock task mode, or the user is otherwise unable to reach device
/// settings.
core.bool networkEscapeHatchEnabled;
/// Whether resetting network settings is disabled.
core.bool networkResetDisabled;
/// Network configuration for the device. See configure networks for more
/// information.
///
/// The values for Object must be JSON objects. It can consist of `num`,
/// `String`, `bool` and `null` as well as `Map` and `List` values.
core.Map<core.String, core.Object> openNetworkConfiguration;
/// Whether using NFC to beam data from apps is disabled.
core.bool outgoingBeamDisabled;
/// Whether outgoing calls are disabled.
core.bool outgoingCallsDisabled;
/// Password requirement policies. Different policies can be set for work
/// profile or fully managed devices by setting the password_scope field in
/// the policy.
core.List<PasswordRequirements> passwordPolicies;
/// Password requirements. The field
/// password_requirements.require_password_unlock must not be set. DEPRECATED
/// - Use password_policies.
PasswordRequirements passwordRequirements;
/// Explicit permission or group grants or denials for all apps. These values
/// override the default_permission_policy.
core.List<PermissionGrant> permissionGrants;
/// Specifies permitted accessibility services. If the field is not set, any
/// accessibility service can be used. If the field is set, only the
/// accessibility services in this list and the system's built-in
/// accessibility service can be used. In particular, if the field is set to
/// empty, only the system's built-in accessibility servicess can be used.
PackageNameList permittedAccessibilityServices;
/// If present, only the input methods provided by packages in this list are
/// permitted. If this field is present, but the list is empty, then only
/// system input methods are permitted.
PackageNameList permittedInputMethods;
/// Default intent handler activities.
core.List<PersistentPreferredActivity> persistentPreferredActivities;
/// Policies managing personal usage on a company-owned device.
PersonalUsagePolicies personalUsagePolicies;
/// This mode controls which apps are available to the user in the Play Store
/// and the behavior on the device when apps are removed from the policy.
/// Possible string values are:
/// - "PLAY_STORE_MODE_UNSPECIFIED" : Unspecified. Defaults to WHITELIST.
/// - "WHITELIST" : Only apps that are in the policy are available and any app
/// not in the policy will be automatically uninstalled from the device.
/// - "BLACKLIST" : All apps are available and any app that should not be on
/// the device should be explicitly marked as 'BLOCKED' in the applications
/// policy.
core.String playStoreMode;
/// Rules that define the behavior when a particular policy can not be applied
/// on device
core.List<PolicyEnforcementRule> policyEnforcementRules;
/// Allows showing UI on a device for a user to choose a private key alias if
/// there are no matching rules in ChoosePrivateKeyRules. For devices below
/// Android P, setting this may leave enterprise keys vulnerable.
core.bool privateKeySelectionEnabled;
/// The network-independent global HTTP proxy. Typically proxies should be
/// configured per-network in open_network_configuration. However for unusual
/// configurations like general internal filtering a global HTTP proxy may be
/// useful. If the proxy is not accessible, network access may break. The
/// global proxy is only a recommendation and some apps may ignore it.
ProxyInfo recommendedGlobalProxy;
/// Whether removing other users is disabled.
core.bool removeUserDisabled;
/// Whether rebooting the device into safe boot is disabled.
core.bool safeBootDisabled;
/// Whether screen capture is disabled.
core.bool screenCaptureDisabled;
/// Whether changing the user icon is disabled.
core.bool setUserIconDisabled;
/// Whether changing the wallpaper is disabled.
core.bool setWallpaperDisabled;
/// Actions to take during the setup process.
core.List<SetupAction> setupActions;
/// Whether location sharing is disabled.
core.bool shareLocationDisabled;
/// A message displayed to the user in the settings screen wherever
/// functionality has been disabled by the admin. If the message is longer
/// than 200 characters it may be truncated.
UserFacingMessage shortSupportMessage;
/// Flag to skip hints on the first use. Enterprise admin can enable the
/// system recommendation for apps to skip their user tutorial and other
/// introductory hints on first start-up.
core.bool skipFirstUseHintsEnabled;
/// Whether sending and receiving SMS messages is disabled.
core.bool smsDisabled;
/// Whether the status bar is disabled. This disables notifications, quick
/// settings, and other screen overlays that allow escape from full-screen
/// mode. DEPRECATED. To disable the status bar on a kiosk device, use
/// InstallType KIOSK or kioskCustomLauncherEnabled.
core.bool statusBarDisabled;
/// Status reporting settings
StatusReportingSettings statusReportingSettings;
/// The battery plugged in modes for which the device stays on. When using
/// this setting, it is recommended to clear maximum_time_to_lock so that the
/// device doesn't lock itself while it stays on.
core.List<core.String> stayOnPluggedModes;
/// The system update policy, which controls how OS updates are applied. If
/// the update type is WINDOWED, the update window will automatically apply to
/// Play app updates as well.
SystemUpdate systemUpdate;
/// Whether configuring tethering and portable hotspots is disabled.
core.bool tetheringConfigDisabled;
/// Whether user uninstallation of applications is disabled.
core.bool uninstallAppsDisabled;
/// Whether the microphone is muted and adjusting microphone volume is
/// disabled.
core.bool unmuteMicrophoneDisabled;
/// Whether transferring files over USB is disabled.
core.bool usbFileTransferDisabled;
/// Whether USB storage is enabled. Deprecated.
core.bool usbMassStorageEnabled;
/// The version of the policy. This is a read-only field. The version is
/// incremented each time the policy is updated.
core.String version;
/// Whether configuring VPN is disabled.
core.bool vpnConfigDisabled;
/// Whether configuring Wi-Fi access points is disabled.
core.bool wifiConfigDisabled;
/// DEPRECATED - Use wifi_config_disabled.
core.bool wifiConfigsLockdownEnabled;
Policy();
Policy.fromJson(core.Map _json) {
if (_json.containsKey('accountTypesWithManagementDisabled')) {
accountTypesWithManagementDisabled =
(_json['accountTypesWithManagementDisabled'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('addUserDisabled')) {
addUserDisabled = _json['addUserDisabled'] as core.bool;
}
if (_json.containsKey('adjustVolumeDisabled')) {
adjustVolumeDisabled = _json['adjustVolumeDisabled'] as core.bool;
}
if (_json.containsKey('advancedSecurityOverrides')) {
advancedSecurityOverrides = AdvancedSecurityOverrides.fromJson(
_json['advancedSecurityOverrides']
as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('alwaysOnVpnPackage')) {
alwaysOnVpnPackage = AlwaysOnVpnPackage.fromJson(
_json['alwaysOnVpnPackage'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('androidDevicePolicyTracks')) {
androidDevicePolicyTracks =
(_json['androidDevicePolicyTracks'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('appAutoUpdatePolicy')) {
appAutoUpdatePolicy = _json['appAutoUpdatePolicy'] as core.String;
}
if (_json.containsKey('applications')) {
applications = (_json['applications'] as core.List)
.map<ApplicationPolicy>((value) => ApplicationPolicy.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('autoTimeRequired')) {
autoTimeRequired = _json['autoTimeRequired'] as core.bool;
}
if (_json.containsKey('blockApplicationsEnabled')) {
blockApplicationsEnabled = _json['blockApplicationsEnabled'] as core.bool;
}
if (_json.containsKey('bluetoothConfigDisabled')) {
bluetoothConfigDisabled = _json['bluetoothConfigDisabled'] as core.bool;
}
if (_json.containsKey('bluetoothContactSharingDisabled')) {
bluetoothContactSharingDisabled =
_json['bluetoothContactSharingDisabled'] as core.bool;
}
if (_json.containsKey('bluetoothDisabled')) {
bluetoothDisabled = _json['bluetoothDisabled'] as core.bool;
}
if (_json.containsKey('cameraDisabled')) {
cameraDisabled = _json['cameraDisabled'] as core.bool;
}
if (_json.containsKey('cellBroadcastsConfigDisabled')) {
cellBroadcastsConfigDisabled =
_json['cellBroadcastsConfigDisabled'] as core.bool;
}
if (_json.containsKey('choosePrivateKeyRules')) {
choosePrivateKeyRules = (_json['choosePrivateKeyRules'] as core.List)
.map<ChoosePrivateKeyRule>((value) => ChoosePrivateKeyRule.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('complianceRules')) {
complianceRules = (_json['complianceRules'] as core.List)
.map<ComplianceRule>((value) => ComplianceRule.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('createWindowsDisabled')) {
createWindowsDisabled = _json['createWindowsDisabled'] as core.bool;
}
if (_json.containsKey('credentialsConfigDisabled')) {
credentialsConfigDisabled =
_json['credentialsConfigDisabled'] as core.bool;
}
if (_json.containsKey('dataRoamingDisabled')) {
dataRoamingDisabled = _json['dataRoamingDisabled'] as core.bool;
}
if (_json.containsKey('debuggingFeaturesAllowed')) {
debuggingFeaturesAllowed = _json['debuggingFeaturesAllowed'] as core.bool;
}
if (_json.containsKey('defaultPermissionPolicy')) {
defaultPermissionPolicy = _json['defaultPermissionPolicy'] as core.String;
}
if (_json.containsKey('deviceOwnerLockScreenInfo')) {
deviceOwnerLockScreenInfo = UserFacingMessage.fromJson(
_json['deviceOwnerLockScreenInfo']
as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('encryptionPolicy')) {
encryptionPolicy = _json['encryptionPolicy'] as core.String;
}
if (_json.containsKey('ensureVerifyAppsEnabled')) {
ensureVerifyAppsEnabled = _json['ensureVerifyAppsEnabled'] as core.bool;
}
if (_json.containsKey('factoryResetDisabled')) {
factoryResetDisabled = _json['factoryResetDisabled'] as core.bool;
}
if (_json.containsKey('frpAdminEmails')) {
frpAdminEmails = (_json['frpAdminEmails'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('funDisabled')) {
funDisabled = _json['funDisabled'] as core.bool;
}
if (_json.containsKey('installAppsDisabled')) {
installAppsDisabled = _json['installAppsDisabled'] as core.bool;
}
if (_json.containsKey('installUnknownSourcesAllowed')) {
installUnknownSourcesAllowed =
_json['installUnknownSourcesAllowed'] as core.bool;
}
if (_json.containsKey('keyguardDisabled')) {
keyguardDisabled = _json['keyguardDisabled'] as core.bool;
}
if (_json.containsKey('keyguardDisabledFeatures')) {
keyguardDisabledFeatures =
(_json['keyguardDisabledFeatures'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('kioskCustomLauncherEnabled')) {
kioskCustomLauncherEnabled =
_json['kioskCustomLauncherEnabled'] as core.bool;
}
if (_json.containsKey('kioskCustomization')) {
kioskCustomization = KioskCustomization.fromJson(
_json['kioskCustomization'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('locationMode')) {
locationMode = _json['locationMode'] as core.String;
}
if (_json.containsKey('longSupportMessage')) {
longSupportMessage = UserFacingMessage.fromJson(
_json['longSupportMessage'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('maximumTimeToLock')) {
maximumTimeToLock = _json['maximumTimeToLock'] as core.String;
}
if (_json.containsKey('minimumApiLevel')) {
minimumApiLevel = _json['minimumApiLevel'] as core.int;
}
if (_json.containsKey('mobileNetworksConfigDisabled')) {
mobileNetworksConfigDisabled =
_json['mobileNetworksConfigDisabled'] as core.bool;
}
if (_json.containsKey('modifyAccountsDisabled')) {
modifyAccountsDisabled = _json['modifyAccountsDisabled'] as core.bool;
}
if (_json.containsKey('mountPhysicalMediaDisabled')) {
mountPhysicalMediaDisabled =
_json['mountPhysicalMediaDisabled'] as core.bool;
}
if (_json.containsKey('name')) {
name = _json['name'] as core.String;
}
if (_json.containsKey('networkEscapeHatchEnabled')) {
networkEscapeHatchEnabled =
_json['networkEscapeHatchEnabled'] as core.bool;
}
if (_json.containsKey('networkResetDisabled')) {
networkResetDisabled = _json['networkResetDisabled'] as core.bool;
}
if (_json.containsKey('openNetworkConfiguration')) {
openNetworkConfiguration = (_json['openNetworkConfiguration'] as core.Map)
.cast<core.String, core.Object>()
.map(
(key, item) => core.MapEntry(
key,
item as core.Object,
),
);
}
if (_json.containsKey('outgoingBeamDisabled')) {
outgoingBeamDisabled = _json['outgoingBeamDisabled'] as core.bool;
}
if (_json.containsKey('outgoingCallsDisabled')) {
outgoingCallsDisabled = _json['outgoingCallsDisabled'] as core.bool;
}
if (_json.containsKey('passwordPolicies')) {
passwordPolicies = (_json['passwordPolicies'] as core.List)
.map<PasswordRequirements>((value) => PasswordRequirements.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('passwordRequirements')) {
passwordRequirements = PasswordRequirements.fromJson(
_json['passwordRequirements'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('permissionGrants')) {
permissionGrants = (_json['permissionGrants'] as core.List)
.map<PermissionGrant>((value) => PermissionGrant.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('permittedAccessibilityServices')) {
permittedAccessibilityServices = PackageNameList.fromJson(
_json['permittedAccessibilityServices']
as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('permittedInputMethods')) {
permittedInputMethods = PackageNameList.fromJson(
_json['permittedInputMethods']
as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('persistentPreferredActivities')) {
persistentPreferredActivities =
(_json['persistentPreferredActivities'] as core.List)
.map<PersistentPreferredActivity>((value) =>
PersistentPreferredActivity.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('personalUsagePolicies')) {
personalUsagePolicies = PersonalUsagePolicies.fromJson(
_json['personalUsagePolicies']
as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('playStoreMode')) {
playStoreMode = _json['playStoreMode'] as core.String;
}
if (_json.containsKey('policyEnforcementRules')) {
policyEnforcementRules = (_json['policyEnforcementRules'] as core.List)
.map<PolicyEnforcementRule>((value) => PolicyEnforcementRule.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('privateKeySelectionEnabled')) {
privateKeySelectionEnabled =
_json['privateKeySelectionEnabled'] as core.bool;
}
if (_json.containsKey('recommendedGlobalProxy')) {
recommendedGlobalProxy = ProxyInfo.fromJson(
_json['recommendedGlobalProxy']
as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('removeUserDisabled')) {
removeUserDisabled = _json['removeUserDisabled'] as core.bool;
}
if (_json.containsKey('safeBootDisabled')) {
safeBootDisabled = _json['safeBootDisabled'] as core.bool;
}
if (_json.containsKey('screenCaptureDisabled')) {
screenCaptureDisabled = _json['screenCaptureDisabled'] as core.bool;
}
if (_json.containsKey('setUserIconDisabled')) {
setUserIconDisabled = _json['setUserIconDisabled'] as core.bool;
}
if (_json.containsKey('setWallpaperDisabled')) {
setWallpaperDisabled = _json['setWallpaperDisabled'] as core.bool;
}
if (_json.containsKey('setupActions')) {
setupActions = (_json['setupActions'] as core.List)
.map<SetupAction>((value) => SetupAction.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('shareLocationDisabled')) {
shareLocationDisabled = _json['shareLocationDisabled'] as core.bool;
}
if (_json.containsKey('shortSupportMessage')) {
shortSupportMessage = UserFacingMessage.fromJson(
_json['shortSupportMessage'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('skipFirstUseHintsEnabled')) {
skipFirstUseHintsEnabled = _json['skipFirstUseHintsEnabled'] as core.bool;
}
if (_json.containsKey('smsDisabled')) {
smsDisabled = _json['smsDisabled'] as core.bool;
}
if (_json.containsKey('statusBarDisabled')) {
statusBarDisabled = _json['statusBarDisabled'] as core.bool;
}
if (_json.containsKey('statusReportingSettings')) {
statusReportingSettings = StatusReportingSettings.fromJson(
_json['statusReportingSettings']
as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('stayOnPluggedModes')) {
stayOnPluggedModes = (_json['stayOnPluggedModes'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('systemUpdate')) {
systemUpdate = SystemUpdate.fromJson(
_json['systemUpdate'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('tetheringConfigDisabled')) {
tetheringConfigDisabled = _json['tetheringConfigDisabled'] as core.bool;
}
if (_json.containsKey('uninstallAppsDisabled')) {
uninstallAppsDisabled = _json['uninstallAppsDisabled'] as core.bool;
}
if (_json.containsKey('unmuteMicrophoneDisabled')) {
unmuteMicrophoneDisabled = _json['unmuteMicrophoneDisabled'] as core.bool;
}
if (_json.containsKey('usbFileTransferDisabled')) {
usbFileTransferDisabled = _json['usbFileTransferDisabled'] as core.bool;
}
if (_json.containsKey('usbMassStorageEnabled')) {
usbMassStorageEnabled = _json['usbMassStorageEnabled'] as core.bool;
}
if (_json.containsKey('version')) {
version = _json['version'] as core.String;
}
if (_json.containsKey('vpnConfigDisabled')) {
vpnConfigDisabled = _json['vpnConfigDisabled'] as core.bool;
}
if (_json.containsKey('wifiConfigDisabled')) {
wifiConfigDisabled = _json['wifiConfigDisabled'] as core.bool;
}
if (_json.containsKey('wifiConfigsLockdownEnabled')) {
wifiConfigsLockdownEnabled =
_json['wifiConfigsLockdownEnabled'] as core.bool;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (accountTypesWithManagementDisabled != null) {
_json['accountTypesWithManagementDisabled'] =
accountTypesWithManagementDisabled;
}
if (addUserDisabled != null) {
_json['addUserDisabled'] = addUserDisabled;
}
if (adjustVolumeDisabled != null) {
_json['adjustVolumeDisabled'] = adjustVolumeDisabled;
}
if (advancedSecurityOverrides != null) {
_json['advancedSecurityOverrides'] = advancedSecurityOverrides.toJson();
}
if (alwaysOnVpnPackage != null) {
_json['alwaysOnVpnPackage'] = alwaysOnVpnPackage.toJson();
}
if (androidDevicePolicyTracks != null) {
_json['androidDevicePolicyTracks'] = androidDevicePolicyTracks;
}
if (appAutoUpdatePolicy != null) {
_json['appAutoUpdatePolicy'] = appAutoUpdatePolicy;
}
if (applications != null) {
_json['applications'] =
applications.map((value) => value.toJson()).toList();
}
if (autoTimeRequired != null) {
_json['autoTimeRequired'] = autoTimeRequired;
}
if (blockApplicationsEnabled != null) {
_json['blockApplicationsEnabled'] = blockApplicationsEnabled;
}
if (bluetoothConfigDisabled != null) {
_json['bluetoothConfigDisabled'] = bluetoothConfigDisabled;
}
if (bluetoothContactSharingDisabled != null) {
_json['bluetoothContactSharingDisabled'] =
bluetoothContactSharingDisabled;
}
if (bluetoothDisabled != null) {
_json['bluetoothDisabled'] = bluetoothDisabled;
}
if (cameraDisabled != null) {
_json['cameraDisabled'] = cameraDisabled;
}
if (cellBroadcastsConfigDisabled != null) {
_json['cellBroadcastsConfigDisabled'] = cellBroadcastsConfigDisabled;
}
if (choosePrivateKeyRules != null) {
_json['choosePrivateKeyRules'] =
choosePrivateKeyRules.map((value) => value.toJson()).toList();
}
if (complianceRules != null) {
_json['complianceRules'] =
complianceRules.map((value) => value.toJson()).toList();
}
if (createWindowsDisabled != null) {
_json['createWindowsDisabled'] = createWindowsDisabled;
}
if (credentialsConfigDisabled != null) {
_json['credentialsConfigDisabled'] = credentialsConfigDisabled;
}
if (dataRoamingDisabled != null) {
_json['dataRoamingDisabled'] = dataRoamingDisabled;
}
if (debuggingFeaturesAllowed != null) {
_json['debuggingFeaturesAllowed'] = debuggingFeaturesAllowed;
}
if (defaultPermissionPolicy != null) {
_json['defaultPermissionPolicy'] = defaultPermissionPolicy;
}
if (deviceOwnerLockScreenInfo != null) {
_json['deviceOwnerLockScreenInfo'] = deviceOwnerLockScreenInfo.toJson();
}
if (encryptionPolicy != null) {
_json['encryptionPolicy'] = encryptionPolicy;
}
if (ensureVerifyAppsEnabled != null) {
_json['ensureVerifyAppsEnabled'] = ensureVerifyAppsEnabled;
}
if (factoryResetDisabled != null) {
_json['factoryResetDisabled'] = factoryResetDisabled;
}
if (frpAdminEmails != null) {
_json['frpAdminEmails'] = frpAdminEmails;
}
if (funDisabled != null) {
_json['funDisabled'] = funDisabled;
}
if (installAppsDisabled != null) {
_json['installAppsDisabled'] = installAppsDisabled;
}
if (installUnknownSourcesAllowed != null) {
_json['installUnknownSourcesAllowed'] = installUnknownSourcesAllowed;
}
if (keyguardDisabled != null) {
_json['keyguardDisabled'] = keyguardDisabled;
}
if (keyguardDisabledFeatures != null) {
_json['keyguardDisabledFeatures'] = keyguardDisabledFeatures;
}
if (kioskCustomLauncherEnabled != null) {
_json['kioskCustomLauncherEnabled'] = kioskCustomLauncherEnabled;
}
if (kioskCustomization != null) {
_json['kioskCustomization'] = kioskCustomization.toJson();
}
if (locationMode != null) {
_json['locationMode'] = locationMode;
}
if (longSupportMessage != null) {
_json['longSupportMessage'] = longSupportMessage.toJson();
}
if (maximumTimeToLock != null) {
_json['maximumTimeToLock'] = maximumTimeToLock;
}
if (minimumApiLevel != null) {
_json['minimumApiLevel'] = minimumApiLevel;
}
if (mobileNetworksConfigDisabled != null) {
_json['mobileNetworksConfigDisabled'] = mobileNetworksConfigDisabled;
}
if (modifyAccountsDisabled != null) {
_json['modifyAccountsDisabled'] = modifyAccountsDisabled;
}
if (mountPhysicalMediaDisabled != null) {
_json['mountPhysicalMediaDisabled'] = mountPhysicalMediaDisabled;
}
if (name != null) {
_json['name'] = name;
}
if (networkEscapeHatchEnabled != null) {
_json['networkEscapeHatchEnabled'] = networkEscapeHatchEnabled;
}
if (networkResetDisabled != null) {
_json['networkResetDisabled'] = networkResetDisabled;
}
if (openNetworkConfiguration != null) {
_json['openNetworkConfiguration'] = openNetworkConfiguration;
}
if (outgoingBeamDisabled != null) {
_json['outgoingBeamDisabled'] = outgoingBeamDisabled;
}
if (outgoingCallsDisabled != null) {
_json['outgoingCallsDisabled'] = outgoingCallsDisabled;
}
if (passwordPolicies != null) {
_json['passwordPolicies'] =
passwordPolicies.map((value) => value.toJson()).toList();
}
if (passwordRequirements != null) {
_json['passwordRequirements'] = passwordRequirements.toJson();
}
if (permissionGrants != null) {
_json['permissionGrants'] =
permissionGrants.map((value) => value.toJson()).toList();
}
if (permittedAccessibilityServices != null) {
_json['permittedAccessibilityServices'] =
permittedAccessibilityServices.toJson();
}
if (permittedInputMethods != null) {
_json['permittedInputMethods'] = permittedInputMethods.toJson();
}
if (persistentPreferredActivities != null) {
_json['persistentPreferredActivities'] =
persistentPreferredActivities.map((value) => value.toJson()).toList();
}
if (personalUsagePolicies != null) {
_json['personalUsagePolicies'] = personalUsagePolicies.toJson();
}
if (playStoreMode != null) {
_json['playStoreMode'] = playStoreMode;
}
if (policyEnforcementRules != null) {
_json['policyEnforcementRules'] =
policyEnforcementRules.map((value) => value.toJson()).toList();
}
if (privateKeySelectionEnabled != null) {
_json['privateKeySelectionEnabled'] = privateKeySelectionEnabled;
}
if (recommendedGlobalProxy != null) {
_json['recommendedGlobalProxy'] = recommendedGlobalProxy.toJson();
}
if (removeUserDisabled != null) {
_json['removeUserDisabled'] = removeUserDisabled;
}
if (safeBootDisabled != null) {
_json['safeBootDisabled'] = safeBootDisabled;
}
if (screenCaptureDisabled != null) {
_json['screenCaptureDisabled'] = screenCaptureDisabled;
}
if (setUserIconDisabled != null) {
_json['setUserIconDisabled'] = setUserIconDisabled;
}
if (setWallpaperDisabled != null) {
_json['setWallpaperDisabled'] = setWallpaperDisabled;
}
if (setupActions != null) {
_json['setupActions'] =
setupActions.map((value) => value.toJson()).toList();
}
if (shareLocationDisabled != null) {
_json['shareLocationDisabled'] = shareLocationDisabled;
}
if (shortSupportMessage != null) {
_json['shortSupportMessage'] = shortSupportMessage.toJson();
}
if (skipFirstUseHintsEnabled != null) {
_json['skipFirstUseHintsEnabled'] = skipFirstUseHintsEnabled;
}
if (smsDisabled != null) {
_json['smsDisabled'] = smsDisabled;
}
if (statusBarDisabled != null) {
_json['statusBarDisabled'] = statusBarDisabled;
}
if (statusReportingSettings != null) {
_json['statusReportingSettings'] = statusReportingSettings.toJson();
}
if (stayOnPluggedModes != null) {
_json['stayOnPluggedModes'] = stayOnPluggedModes;
}
if (systemUpdate != null) {
_json['systemUpdate'] = systemUpdate.toJson();
}
if (tetheringConfigDisabled != null) {
_json['tetheringConfigDisabled'] = tetheringConfigDisabled;
}
if (uninstallAppsDisabled != null) {
_json['uninstallAppsDisabled'] = uninstallAppsDisabled;
}
if (unmuteMicrophoneDisabled != null) {
_json['unmuteMicrophoneDisabled'] = unmuteMicrophoneDisabled;
}
if (usbFileTransferDisabled != null) {
_json['usbFileTransferDisabled'] = usbFileTransferDisabled;
}
if (usbMassStorageEnabled != null) {
_json['usbMassStorageEnabled'] = usbMassStorageEnabled;
}
if (version != null) {
_json['version'] = version;
}
if (vpnConfigDisabled != null) {
_json['vpnConfigDisabled'] = vpnConfigDisabled;
}
if (wifiConfigDisabled != null) {
_json['wifiConfigDisabled'] = wifiConfigDisabled;
}
if (wifiConfigsLockdownEnabled != null) {
_json['wifiConfigsLockdownEnabled'] = wifiConfigsLockdownEnabled;
}
return _json;
}
}
/// A rule that defines the actions to take if a device or work profile is not
/// compliant with the policy specified in settingName.
class PolicyEnforcementRule {
/// An action to block access to apps and data on a fully managed device or in
/// a work profile. This action also triggers a user-facing notification with
/// information (where possible) on how to correct the compliance issue. Note:
/// wipeAction must also be specified.
BlockAction blockAction;
/// The top-level policy to enforce. For example, applications or
/// passwordPolicies.
core.String settingName;
/// An action to reset a fully managed device or delete a work profile. Note:
/// blockAction must also be specified.
WipeAction wipeAction;
PolicyEnforcementRule();
PolicyEnforcementRule.fromJson(core.Map _json) {
if (_json.containsKey('blockAction')) {
blockAction = BlockAction.fromJson(
_json['blockAction'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('settingName')) {
settingName = _json['settingName'] as core.String;
}
if (_json.containsKey('wipeAction')) {
wipeAction = WipeAction.fromJson(
_json['wipeAction'] as core.Map<core.String, core.dynamic>);
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (blockAction != null) {
_json['blockAction'] = blockAction.toJson();
}
if (settingName != null) {
_json['settingName'] = settingName;
}
if (wipeAction != null) {
_json['wipeAction'] = wipeAction.toJson();
}
return _json;
}
}
/// Additional details regarding the security posture of the device.
class PostureDetail {
/// Corresponding admin-facing advice to mitigate this security risk and
/// improve the security posture of the device.
core.List<UserFacingMessage> advice;
/// A specific security risk that negatively affects the security posture of
/// the device.
/// Possible string values are:
/// - "SECURITY_RISK_UNSPECIFIED" : Unspecified.
/// - "UNKNOWN_OS" : SafetyNet detects that the device is running an unknown
/// OS (basicIntegrity check succeeds but ctsProfileMatch fails).
/// - "COMPROMISED_OS" : SafetyNet detects that the device is running a
/// compromised OS (basicIntegrity check fails).
core.String securityRisk;
PostureDetail();
PostureDetail.fromJson(core.Map _json) {
if (_json.containsKey('advice')) {
advice = (_json['advice'] as core.List)
.map<UserFacingMessage>((value) => UserFacingMessage.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('securityRisk')) {
securityRisk = _json['securityRisk'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (advice != null) {
_json['advice'] = advice.map((value) => value.toJson()).toList();
}
if (securityRisk != null) {
_json['securityRisk'] = securityRisk;
}
return _json;
}
}
/// A power management event.
class PowerManagementEvent {
/// For BATTERY_LEVEL_COLLECTED events, the battery level as a percentage.
core.double batteryLevel;
/// The creation time of the event.
core.String createTime;
/// Event type.
/// Possible string values are:
/// - "POWER_MANAGEMENT_EVENT_TYPE_UNSPECIFIED" : Unspecified. No events have
/// this type.
/// - "BATTERY_LEVEL_COLLECTED" : Battery level was measured.
/// - "POWER_CONNECTED" : The device started charging.
/// - "POWER_DISCONNECTED" : The device stopped charging.
/// - "BATTERY_LOW" : The device entered low-power mode.
/// - "BATTERY_OKAY" : The device exited low-power mode.
/// - "BOOT_COMPLETED" : The device booted.
/// - "SHUTDOWN" : The device shut down.
core.String eventType;
PowerManagementEvent();
PowerManagementEvent.fromJson(core.Map _json) {
if (_json.containsKey('batteryLevel')) {
batteryLevel = (_json['batteryLevel'] as core.num).toDouble();
}
if (_json.containsKey('createTime')) {
createTime = _json['createTime'] as core.String;
}
if (_json.containsKey('eventType')) {
eventType = _json['eventType'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (batteryLevel != null) {
_json['batteryLevel'] = batteryLevel;
}
if (createTime != null) {
_json['createTime'] = createTime;
}
if (eventType != null) {
_json['eventType'] = eventType;
}
return _json;
}
}
/// Configuration info for an HTTP proxy. For a direct proxy, set the host,
/// port, and excluded_hosts fields. For a PAC script proxy, set the pac_uri
/// field.
class ProxyInfo {
/// For a direct proxy, the hosts for which the proxy is bypassed. The host
/// names may contain wildcards such as *.example.com.
core.List<core.String> excludedHosts;
/// The host of the direct proxy.
core.String host;
/// The URI of the PAC script used to configure the proxy.
core.String pacUri;
/// The port of the direct proxy.
core.int port;
ProxyInfo();
ProxyInfo.fromJson(core.Map _json) {
if (_json.containsKey('excludedHosts')) {
excludedHosts = (_json['excludedHosts'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('host')) {
host = _json['host'] as core.String;
}
if (_json.containsKey('pacUri')) {
pacUri = _json['pacUri'] as core.String;
}
if (_json.containsKey('port')) {
port = _json['port'] as core.int;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (excludedHosts != null) {
_json['excludedHosts'] = excludedHosts;
}
if (host != null) {
_json['host'] = host;
}
if (pacUri != null) {
_json['pacUri'] = pacUri;
}
if (port != null) {
_json['port'] = port;
}
return _json;
}
}
/// The security posture of the device, as determined by the current device
/// state and the policies applied.
class SecurityPosture {
/// Device's security posture value.
/// Possible string values are:
/// - "POSTURE_UNSPECIFIED" : Unspecified. There is no posture detail for this
/// posture value.
/// - "SECURE" : This device is secure.
/// - "AT_RISK" : This device may be more vulnerable to malicious actors than
/// is recommended for use with corporate data.
/// - "POTENTIALLY_COMPROMISED" : This device may be compromised and corporate
/// data may be accessible to unauthorized actors.
core.String devicePosture;
/// Additional details regarding the security posture of the device.
core.List<PostureDetail> postureDetails;
SecurityPosture();
SecurityPosture.fromJson(core.Map _json) {
if (_json.containsKey('devicePosture')) {
devicePosture = _json['devicePosture'] as core.String;
}
if (_json.containsKey('postureDetails')) {
postureDetails = (_json['postureDetails'] as core.List)
.map<PostureDetail>((value) => PostureDetail.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (devicePosture != null) {
_json['devicePosture'] = devicePosture;
}
if (postureDetails != null) {
_json['postureDetails'] =
postureDetails.map((value) => value.toJson()).toList();
}
return _json;
}
}
/// An action executed during setup.
class SetupAction {
/// Description of this action.
UserFacingMessage description;
/// An action to launch an app.
LaunchAppAction launchApp;
/// Title of this action.
UserFacingMessage title;
SetupAction();
SetupAction.fromJson(core.Map _json) {
if (_json.containsKey('description')) {
description = UserFacingMessage.fromJson(
_json['description'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('launchApp')) {
launchApp = LaunchAppAction.fromJson(
_json['launchApp'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('title')) {
title = UserFacingMessage.fromJson(
_json['title'] as core.Map<core.String, core.dynamic>);
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (description != null) {
_json['description'] = description.toJson();
}
if (launchApp != null) {
_json['launchApp'] = launchApp.toJson();
}
if (title != null) {
_json['title'] = title.toJson();
}
return _json;
}
}
/// A resource containing sign in details for an enterprise.
class SigninDetail {
/// Controls whether personal usage is allowed on a device provisioned with
/// this enrollment token.For company-owned devices: Enabling personal usage
/// allows the user to set up a work profile on the device. Disabling personal
/// usage requires the user provision the device as a fully managed device.For
/// personally-owned devices: Enabling personal usage allows the user to set
/// up a work profile on the device. Disabling personal usage will prevent the
/// device from provisioning. Personal usage cannot be disabled on
/// personally-owned device.
/// Possible string values are:
/// - "ALLOW_PERSONAL_USAGE_UNSPECIFIED" : Personal usage restriction is not
/// specified
/// - "PERSONAL_USAGE_ALLOWED" : Personal usage is allowed
/// - "PERSONAL_USAGE_DISALLOWED" : Personal usage is disallowed
core.String allowPersonalUsage;
/// A JSON string whose UTF-8 representation can be used to generate a QR code
/// to enroll a device with this enrollment token. To enroll a device using
/// NFC, the NFC record must contain a serialized java.util.Properties
/// representation of the properties in the JSON. This is a read-only field
/// generated by the server.
core.String qrCode;
/// An enterprise wide enrollment token used to trigger custom sign-in flow.
/// This is a read-only field generated by the server.
core.String signinEnrollmentToken;
/// Sign-in URL for authentication when device is provisioned with a sign-in
/// enrollment token. The sign-in endpoint should finish authentication flow
/// with a URL in the form of https://enterprise.google.com/android/enroll?et=
/// for a successful login, or
/// https://enterprise.google.com/android/enroll/invalid for a failed login.
core.String signinUrl;
SigninDetail();
SigninDetail.fromJson(core.Map _json) {
if (_json.containsKey('allowPersonalUsage')) {
allowPersonalUsage = _json['allowPersonalUsage'] as core.String;
}
if (_json.containsKey('qrCode')) {
qrCode = _json['qrCode'] as core.String;
}
if (_json.containsKey('signinEnrollmentToken')) {
signinEnrollmentToken = _json['signinEnrollmentToken'] as core.String;
}
if (_json.containsKey('signinUrl')) {
signinUrl = _json['signinUrl'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (allowPersonalUsage != null) {
_json['allowPersonalUsage'] = allowPersonalUsage;
}
if (qrCode != null) {
_json['qrCode'] = qrCode;
}
if (signinEnrollmentToken != null) {
_json['signinEnrollmentToken'] = signinEnrollmentToken;
}
if (signinUrl != null) {
_json['signinUrl'] = signinUrl;
}
return _json;
}
}
/// An enterprise signup URL.
class SignupUrl {
/// The name of the resource. Use this value in the signupUrl field when
/// calling enterprises.create to complete the enterprise signup flow.
core.String name;
/// A URL where an enterprise admin can register their enterprise. The page
/// can't be rendered in an iframe.
core.String url;
SignupUrl();
SignupUrl.fromJson(core.Map _json) {
if (_json.containsKey('name')) {
name = _json['name'] as core.String;
}
if (_json.containsKey('url')) {
url = _json['url'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (name != null) {
_json['name'] = name;
}
if (url != null) {
_json['url'] = url;
}
return _json;
}
}
/// Information about device software.
class SoftwareInfo {
/// Android build ID string meant for displaying to the user. For example,
/// shamu-userdebug 6.0.1 MOB30I 2756745 dev-keys.
core.String androidBuildNumber;
/// Build time.
core.String androidBuildTime;
/// The Android Device Policy app version code.
core.int androidDevicePolicyVersionCode;
/// The Android Device Policy app version as displayed to the user.
core.String androidDevicePolicyVersionName;
/// The user-visible Android version string. For example, 6.0.1.
core.String androidVersion;
/// The system bootloader version number, e.g. 0.6.7.
core.String bootloaderVersion;
/// SHA-256 hash of android.content.pm.Signature
/// (https://developer.android.com/reference/android/content/pm/Signature.html)
/// associated with the system package, which can be used to verify that the
/// system build hasn't been modified.
core.String deviceBuildSignature;
/// Kernel version, for example, 2.6.32.9-g103d848.
core.String deviceKernelVersion;
/// An IETF BCP 47 language code for the primary locale on the device.
core.String primaryLanguageCode;
/// Security patch level, e.g. 2016-05-01.
core.String securityPatchLevel;
/// Information about a potential pending system update.
SystemUpdateInfo systemUpdateInfo;
SoftwareInfo();
SoftwareInfo.fromJson(core.Map _json) {
if (_json.containsKey('androidBuildNumber')) {
androidBuildNumber = _json['androidBuildNumber'] as core.String;
}
if (_json.containsKey('androidBuildTime')) {
androidBuildTime = _json['androidBuildTime'] as core.String;
}
if (_json.containsKey('androidDevicePolicyVersionCode')) {
androidDevicePolicyVersionCode =
_json['androidDevicePolicyVersionCode'] as core.int;
}
if (_json.containsKey('androidDevicePolicyVersionName')) {
androidDevicePolicyVersionName =
_json['androidDevicePolicyVersionName'] as core.String;
}
if (_json.containsKey('androidVersion')) {
androidVersion = _json['androidVersion'] as core.String;
}
if (_json.containsKey('bootloaderVersion')) {
bootloaderVersion = _json['bootloaderVersion'] as core.String;
}
if (_json.containsKey('deviceBuildSignature')) {
deviceBuildSignature = _json['deviceBuildSignature'] as core.String;
}
if (_json.containsKey('deviceKernelVersion')) {
deviceKernelVersion = _json['deviceKernelVersion'] as core.String;
}
if (_json.containsKey('primaryLanguageCode')) {
primaryLanguageCode = _json['primaryLanguageCode'] as core.String;
}
if (_json.containsKey('securityPatchLevel')) {
securityPatchLevel = _json['securityPatchLevel'] as core.String;
}
if (_json.containsKey('systemUpdateInfo')) {
systemUpdateInfo = SystemUpdateInfo.fromJson(
_json['systemUpdateInfo'] as core.Map<core.String, core.dynamic>);
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (androidBuildNumber != null) {
_json['androidBuildNumber'] = androidBuildNumber;
}
if (androidBuildTime != null) {
_json['androidBuildTime'] = androidBuildTime;
}
if (androidDevicePolicyVersionCode != null) {
_json['androidDevicePolicyVersionCode'] = androidDevicePolicyVersionCode;
}
if (androidDevicePolicyVersionName != null) {
_json['androidDevicePolicyVersionName'] = androidDevicePolicyVersionName;
}
if (androidVersion != null) {
_json['androidVersion'] = androidVersion;
}
if (bootloaderVersion != null) {
_json['bootloaderVersion'] = bootloaderVersion;
}
if (deviceBuildSignature != null) {
_json['deviceBuildSignature'] = deviceBuildSignature;
}
if (deviceKernelVersion != null) {
_json['deviceKernelVersion'] = deviceKernelVersion;
}
if (primaryLanguageCode != null) {
_json['primaryLanguageCode'] = primaryLanguageCode;
}
if (securityPatchLevel != null) {
_json['securityPatchLevel'] = securityPatchLevel;
}
if (systemUpdateInfo != null) {
_json['systemUpdateInfo'] = systemUpdateInfo.toJson();
}
return _json;
}
}
/// The Status type defines a logical error model that is suitable for different
/// programming environments, including REST APIs and RPC APIs. It is used by
/// gRPC (https://github.com/grpc). Each Status message contains three pieces of
/// data: error code, error message, and error details.You can find out more
/// about this error model and how to work with it in the API Design Guide
/// (https://cloud.google.com/apis/design/errors).
class Status {
/// The status code, which should be an enum value of google.rpc.Code.
core.int code;
/// A list of messages that carry the error details. There is a common set of
/// message types for APIs to use.
///
/// The values for Object must be JSON objects. It can consist of `num`,
/// `String`, `bool` and `null` as well as `Map` and `List` values.
core.List<core.Map<core.String, core.Object>> details;
/// A developer-facing error message, which should be in English. Any
/// user-facing error message should be localized and sent in the
/// google.rpc.Status.details field, or localized by the client.
core.String message;
Status();
Status.fromJson(core.Map _json) {
if (_json.containsKey('code')) {
code = _json['code'] as core.int;
}
if (_json.containsKey('details')) {
details = (_json['details'] as core.List)
.map<core.Map<core.String, core.Object>>((value) =>
(value as core.Map).cast<core.String, core.Object>().map(
(key, item) => core.MapEntry(
key,
item as core.Object,
),
))
.toList();
}
if (_json.containsKey('message')) {
message = _json['message'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (code != null) {
_json['code'] = code;
}
if (details != null) {
_json['details'] = details;
}
if (message != null) {
_json['message'] = message;
}
return _json;
}
}
/// Settings controlling the behavior of status reports.
class StatusReportingSettings {
/// Application reporting settings. Only applicable if
/// application_reports_enabled is true.
ApplicationReportingSettings applicationReportingSettings;
/// Whether app reports are enabled.
core.bool applicationReportsEnabled;
/// Whether device settings reporting is enabled.
core.bool deviceSettingsEnabled;
/// Whether displays reporting is enabled. Report data is not available for
/// personally owned devices with work profiles.
core.bool displayInfoEnabled;
/// Whether hardware status reporting is enabled. Report data is not available
/// for personally owned devices with work profiles.
core.bool hardwareStatusEnabled;
/// Whether memory reporting is enabled.
core.bool memoryInfoEnabled;
/// Whether network info reporting is enabled.
core.bool networkInfoEnabled;
/// Whether power management event reporting is enabled. Report data is not
/// available for personally owned devices with work profiles.
core.bool powerManagementEventsEnabled;
/// Whether software info reporting is enabled.
core.bool softwareInfoEnabled;
/// Whether system properties reporting is enabled.
core.bool systemPropertiesEnabled;
StatusReportingSettings();
StatusReportingSettings.fromJson(core.Map _json) {
if (_json.containsKey('applicationReportingSettings')) {
applicationReportingSettings = ApplicationReportingSettings.fromJson(
_json['applicationReportingSettings']
as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('applicationReportsEnabled')) {
applicationReportsEnabled =
_json['applicationReportsEnabled'] as core.bool;
}
if (_json.containsKey('deviceSettingsEnabled')) {
deviceSettingsEnabled = _json['deviceSettingsEnabled'] as core.bool;
}
if (_json.containsKey('displayInfoEnabled')) {
displayInfoEnabled = _json['displayInfoEnabled'] as core.bool;
}
if (_json.containsKey('hardwareStatusEnabled')) {
hardwareStatusEnabled = _json['hardwareStatusEnabled'] as core.bool;
}
if (_json.containsKey('memoryInfoEnabled')) {
memoryInfoEnabled = _json['memoryInfoEnabled'] as core.bool;
}
if (_json.containsKey('networkInfoEnabled')) {
networkInfoEnabled = _json['networkInfoEnabled'] as core.bool;
}
if (_json.containsKey('powerManagementEventsEnabled')) {
powerManagementEventsEnabled =
_json['powerManagementEventsEnabled'] as core.bool;
}
if (_json.containsKey('softwareInfoEnabled')) {
softwareInfoEnabled = _json['softwareInfoEnabled'] as core.bool;
}
if (_json.containsKey('systemPropertiesEnabled')) {
systemPropertiesEnabled = _json['systemPropertiesEnabled'] as core.bool;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (applicationReportingSettings != null) {
_json['applicationReportingSettings'] =
applicationReportingSettings.toJson();
}
if (applicationReportsEnabled != null) {
_json['applicationReportsEnabled'] = applicationReportsEnabled;
}
if (deviceSettingsEnabled != null) {
_json['deviceSettingsEnabled'] = deviceSettingsEnabled;
}
if (displayInfoEnabled != null) {
_json['displayInfoEnabled'] = displayInfoEnabled;
}
if (hardwareStatusEnabled != null) {
_json['hardwareStatusEnabled'] = hardwareStatusEnabled;
}
if (memoryInfoEnabled != null) {
_json['memoryInfoEnabled'] = memoryInfoEnabled;
}
if (networkInfoEnabled != null) {
_json['networkInfoEnabled'] = networkInfoEnabled;
}
if (powerManagementEventsEnabled != null) {
_json['powerManagementEventsEnabled'] = powerManagementEventsEnabled;
}
if (softwareInfoEnabled != null) {
_json['softwareInfoEnabled'] = softwareInfoEnabled;
}
if (systemPropertiesEnabled != null) {
_json['systemPropertiesEnabled'] = systemPropertiesEnabled;
}
return _json;
}
}
/// Configuration for managing system updates
class SystemUpdate {
/// If the type is WINDOWED, the end of the maintenance window, measured as
/// the number of minutes after midnight in device's local time. This value
/// must be between 0 and 1439, inclusive. If this value is less than
/// start_minutes, then the maintenance window spans midnight. If the
/// maintenance window specified is smaller than 30 minutes, the actual window
/// is extended to 30 minutes beyond the start time.
core.int endMinutes;
/// An annually repeating time period in which over-the-air (OTA) system
/// updates are postponed to freeze the OS version running on a device. To
/// prevent freezing the device indefinitely, each freeze period must be
/// separated by at least 60 days.
core.List<FreezePeriod> freezePeriods;
/// If the type is WINDOWED, the start of the maintenance window, measured as
/// the number of minutes after midnight in the device's local time. This
/// value must be between 0 and 1439, inclusive.
core.int startMinutes;
/// The type of system update to configure.
/// Possible string values are:
/// - "SYSTEM_UPDATE_TYPE_UNSPECIFIED" : Follow the default update behavior
/// for the device, which typically requires the user to accept system
/// updates.
/// - "AUTOMATIC" : Install automatically as soon as an update is available.
/// - "WINDOWED" : Install automatically within a daily maintenance window.
/// This also configures Play apps to be updated within the window. This is
/// strongly recommended for kiosk devices because this is the only way apps
/// persistently pinned to the foreground can be updated by Play.
/// - "POSTPONE" : Postpone automatic install up to a maximum of 30 days.
core.String type;
SystemUpdate();
SystemUpdate.fromJson(core.Map _json) {
if (_json.containsKey('endMinutes')) {
endMinutes = _json['endMinutes'] as core.int;
}
if (_json.containsKey('freezePeriods')) {
freezePeriods = (_json['freezePeriods'] as core.List)
.map<FreezePeriod>((value) => FreezePeriod.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('startMinutes')) {
startMinutes = _json['startMinutes'] as core.int;
}
if (_json.containsKey('type')) {
type = _json['type'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (endMinutes != null) {
_json['endMinutes'] = endMinutes;
}
if (freezePeriods != null) {
_json['freezePeriods'] =
freezePeriods.map((value) => value.toJson()).toList();
}
if (startMinutes != null) {
_json['startMinutes'] = startMinutes;
}
if (type != null) {
_json['type'] = type;
}
return _json;
}
}
/// Information about a potential pending system update.
class SystemUpdateInfo {
/// The time when the update was first available. A zero value indicates that
/// this field is not set. This field is set only if an update is available
/// (that is, updateStatus is neither UPDATE_STATUS_UNKNOWN nor UP_TO_DATE).
core.String updateReceivedTime;
/// The status of an update: whether an update exists and what type it is.
/// Possible string values are:
/// - "UPDATE_STATUS_UNKNOWN" : It is unknown whether there is a pending
/// system update. This happens when, for example, the device API level is
/// less than 26, or if the version of Android Device Policy is outdated.
/// - "UP_TO_DATE" : There is no pending system update available on the
/// device.
/// - "UNKNOWN_UPDATE_AVAILABLE" : There is a pending system update available,
/// but its type is not known.
/// - "SECURITY_UPDATE_AVAILABLE" : There is a pending security update
/// available.
/// - "OS_UPDATE_AVAILABLE" : There is a pending OS update available.
core.String updateStatus;
SystemUpdateInfo();
SystemUpdateInfo.fromJson(core.Map _json) {
if (_json.containsKey('updateReceivedTime')) {
updateReceivedTime = _json['updateReceivedTime'] as core.String;
}
if (_json.containsKey('updateStatus')) {
updateStatus = _json['updateStatus'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (updateReceivedTime != null) {
_json['updateReceivedTime'] = updateReceivedTime;
}
if (updateStatus != null) {
_json['updateStatus'] = updateStatus;
}
return _json;
}
}
/// A terms and conditions page to be accepted during provisioning.
class TermsAndConditions {
/// A well-formatted HTML string. It will be parsed on the client with
/// android.text.Html#fromHtml.
UserFacingMessage content;
/// A short header which appears above the HTML content.
UserFacingMessage header;
TermsAndConditions();
TermsAndConditions.fromJson(core.Map _json) {
if (_json.containsKey('content')) {
content = UserFacingMessage.fromJson(
_json['content'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('header')) {
header = UserFacingMessage.fromJson(
_json['header'] as core.Map<core.String, core.dynamic>);
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (content != null) {
_json['content'] = content.toJson();
}
if (header != null) {
_json['header'] = header.toJson();
}
return _json;
}
}
/// A user belonging to an enterprise.
class User {
/// A unique identifier you create for this user, such as user342 or
/// asset#44418. This field must be set when the user is created and can't be
/// updated. This field must not contain personally identifiable information
/// (PII). This identifier must be 1024 characters or less; otherwise, the
/// update policy request will fail.
core.String accountIdentifier;
User();
User.fromJson(core.Map _json) {
if (_json.containsKey('accountIdentifier')) {
accountIdentifier = _json['accountIdentifier'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (accountIdentifier != null) {
_json['accountIdentifier'] = accountIdentifier;
}
return _json;
}
}
/// Provides a user-facing message with locale info. The maximum message length
/// is 4096 characters.
class UserFacingMessage {
/// The default message displayed if no localized message is specified or the
/// user's locale doesn't match with any of the localized messages. A default
/// message must be provided if any localized messages are provided.
core.String defaultMessage;
/// A map containing pairs, where locale is a well-formed BCP 47 language
/// (https://www.w3.org/International/articles/language-tags/) code, such as
/// en-US, es-ES, or fr.
core.Map<core.String, core.String> localizedMessages;
UserFacingMessage();
UserFacingMessage.fromJson(core.Map _json) {
if (_json.containsKey('defaultMessage')) {
defaultMessage = _json['defaultMessage'] as core.String;
}
if (_json.containsKey('localizedMessages')) {
localizedMessages = (_json['localizedMessages'] as core.Map)
.cast<core.String, core.String>()
.map(
(key, item) => core.MapEntry(
key,
item as core.String,
),
);
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (defaultMessage != null) {
_json['defaultMessage'] = defaultMessage;
}
if (localizedMessages != null) {
_json['localizedMessages'] = localizedMessages;
}
return _json;
}
}
/// A web app.
class WebApp {
/// The display mode of the web app.
/// Possible string values are:
/// - "DISPLAY_MODE_UNSPECIFIED" : Not used.
/// - "MINIMAL_UI" : Opens the web app with a minimal set of browser UI
/// elements for controlling navigation and viewing the page URL.
/// - "STANDALONE" : Opens the web app to look and feel like a standalone
/// native application. The browser UI elements and page URL are not visible,
/// however the system status bar and back button are visible.
/// - "FULL_SCREEN" : Opens the web app in full screen without any visible
/// controls. The browser UI elements, page URL, system status bar and back
/// button are not visible, and the web app takes up the entirety of the
/// available display area.
core.String displayMode;
/// A list of icons for the web app. Must have at least one element.
core.List<WebAppIcon> icons;
/// The name of the web app, which is generated by the server during creation
/// in the form enterprises/{enterpriseId}/webApps/{packageName}.
core.String name;
/// The start URL, i.e. the URL that should load when the user opens the
/// application.
core.String startUrl;
/// The title of the web app as displayed to the user (e.g., amongst a list of
/// other applications, or as a label for an icon).
core.String title;
/// The current version of the app.Note that the version can automatically
/// increase during the lifetime of the web app, while Google does internal
/// housekeeping to keep the web app up-to-date.
core.String versionCode;
WebApp();
WebApp.fromJson(core.Map _json) {
if (_json.containsKey('displayMode')) {
displayMode = _json['displayMode'] as core.String;
}
if (_json.containsKey('icons')) {
icons = (_json['icons'] as core.List)
.map<WebAppIcon>((value) =>
WebAppIcon.fromJson(value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('name')) {
name = _json['name'] as core.String;
}
if (_json.containsKey('startUrl')) {
startUrl = _json['startUrl'] as core.String;
}
if (_json.containsKey('title')) {
title = _json['title'] as core.String;
}
if (_json.containsKey('versionCode')) {
versionCode = _json['versionCode'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (displayMode != null) {
_json['displayMode'] = displayMode;
}
if (icons != null) {
_json['icons'] = icons.map((value) => value.toJson()).toList();
}
if (name != null) {
_json['name'] = name;
}
if (startUrl != null) {
_json['startUrl'] = startUrl;
}
if (title != null) {
_json['title'] = title;
}
if (versionCode != null) {
_json['versionCode'] = versionCode;
}
return _json;
}
}
/// An icon for a web app. Supported formats are: png, jpg and webp.
class WebAppIcon {
/// The actual bytes of the image in a base64url encoded string (c.f. RFC4648,
/// section 5 "Base 64 Encoding with URL and Filename Safe Alphabet"). - The
/// image type can be png or jpg. - The image should ideally be square. - The
/// image should ideally have a size of 512x512.
core.String imageData;
WebAppIcon();
WebAppIcon.fromJson(core.Map _json) {
if (_json.containsKey('imageData')) {
imageData = _json['imageData'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (imageData != null) {
_json['imageData'] = imageData;
}
return _json;
}
}
/// A web token used to access the managed Google Play iframe.
class WebToken {
/// The features to enable. Use this if you want to control exactly which
/// feature(s) will be activated; leave empty to allow all
/// features.Restrictions / things to note: - If no features are listed here,
/// all features are enabled — this is the default behavior where you give
/// access to all features to your admins. - This must not contain any
/// FEATURE_UNSPECIFIED values. - Repeated values are ignored
core.List<core.String> enabledFeatures;
/// The name of the web token, which is generated by the server during
/// creation in the form enterprises/{enterpriseId}/webTokens/{webTokenId}.
core.String name;
/// The URL of the parent frame hosting the iframe with the embedded UI. To
/// prevent XSS, the iframe may not be hosted at other URLs. The URL must use
/// the https scheme.
core.String parentFrameUrl;
/// Permissions available to an admin in the embedded UI. An admin must have
/// all of these permissions in order to view the UI. This field is
/// deprecated.
core.List<core.String> permissions;
/// The token value which is used in the hosting page to generate the iframe
/// with the embedded UI. This is a read-only field generated by the server.
core.String value;
WebToken();
WebToken.fromJson(core.Map _json) {
if (_json.containsKey('enabledFeatures')) {
enabledFeatures = (_json['enabledFeatures'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('name')) {
name = _json['name'] as core.String;
}
if (_json.containsKey('parentFrameUrl')) {
parentFrameUrl = _json['parentFrameUrl'] as core.String;
}
if (_json.containsKey('permissions')) {
permissions = (_json['permissions'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('value')) {
value = _json['value'] as core.String;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (enabledFeatures != null) {
_json['enabledFeatures'] = enabledFeatures;
}
if (name != null) {
_json['name'] = name;
}
if (parentFrameUrl != null) {
_json['parentFrameUrl'] = parentFrameUrl;
}
if (permissions != null) {
_json['permissions'] = permissions;
}
if (value != null) {
_json['value'] = value;
}
return _json;
}
}
/// An action to reset a fully managed device or delete a work profile. Note:
/// blockAction must also be specified.
class WipeAction {
/// Whether the factory-reset protection data is preserved on the device. This
/// setting doesn’t apply to work profiles.
core.bool preserveFrp;
/// Number of days the policy is non-compliant before the device or work
/// profile is wiped. wipeAfterDays must be greater than blockAfterDays.
core.int wipeAfterDays;
WipeAction();
WipeAction.fromJson(core.Map _json) {
if (_json.containsKey('preserveFrp')) {
preserveFrp = _json['preserveFrp'] as core.bool;
}
if (_json.containsKey('wipeAfterDays')) {
wipeAfterDays = _json['wipeAfterDays'] as core.int;
}
}
core.Map<core.String, core.Object> toJson() {
final _json = <core.String, core.Object>{};
if (preserveFrp != null) {
_json['preserveFrp'] = preserveFrp;
}
if (wipeAfterDays != null) {
_json['wipeAfterDays'] = wipeAfterDays;
}
return _json;
}
}