Google Git
Sign in
flutter / third_party / googleapis.dart / af84e107c0edee1fdeda589046370fd3733fc590 / . / generated / googleapis_beta / lib / networkconnectivity / v1alpha1.dart
blob: 7d72b9827e9160a98db425950c2d7c5f79d92100 [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_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_string_interpolations
/// Network Connectivity API - v1alpha1
///
/// The Network Connectivity API will be home to various services which provide
/// information pertaining to network connectivity.
///
/// For more information, see
/// <https://cloud.google.com/network-connectivity/docs>
///
/// Create an instance of [NetworkconnectivityApi] to access these resources:
///
/// - [ProjectsResource]
/// - [ProjectsLocationsResource]
/// - [ProjectsLocationsGlobalResource]
/// - [ProjectsLocationsGlobalHubsResource]
/// - [ProjectsLocationsOperationsResource]
/// - [ProjectsLocationsPolicyBasedRoutesResource]
/// - [ProjectsLocationsPrivateRangesResource]
/// - [ProjectsLocationsSpokesResource]
library networkconnectivity.v1alpha1;
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 Network Connectivity API will be home to various services which provide
/// information pertaining to network connectivity.
class NetworkconnectivityApi {
/// View and manage your data across Google Cloud Platform services
static const cloudPlatformScope =
'https://www.googleapis.com/auth/cloud-platform';
final commons.ApiRequester _requester;
ProjectsResource get projects => ProjectsResource(_requester);
NetworkconnectivityApi(http.Client client,
{core.String rootUrl = 'https://networkconnectivity.googleapis.com/',
core.String servicePath = ''})
: _requester =
commons.ApiRequester(client, rootUrl, servicePath, userAgent);
}
class ProjectsResource {
final commons.ApiRequester _requester;
ProjectsLocationsResource get locations =>
ProjectsLocationsResource(_requester);
ProjectsResource(commons.ApiRequester client) : _requester = client;
}
class ProjectsLocationsResource {
final commons.ApiRequester _requester;
ProjectsLocationsGlobalResource get global =>
ProjectsLocationsGlobalResource(_requester);
ProjectsLocationsOperationsResource get operations =>
ProjectsLocationsOperationsResource(_requester);
ProjectsLocationsPolicyBasedRoutesResource get policyBasedRoutes =>
ProjectsLocationsPolicyBasedRoutesResource(_requester);
ProjectsLocationsPrivateRangesResource get privateRanges =>
ProjectsLocationsPrivateRangesResource(_requester);
ProjectsLocationsSpokesResource get spokes =>
ProjectsLocationsSpokesResource(_requester);
ProjectsLocationsResource(commons.ApiRequester client) : _requester = client;
/// Gets information about a location.
///
/// Request parameters:
///
/// [name] - Resource name for the location.
/// Value must have pattern `^projects/\[^/\]+/locations/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Location].
///
/// 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<Location> get(
core.String name, {
core.String? $fields,
}) async {
final _queryParams = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' + commons.Escaper.ecapeVariableReserved('$name');
final _response = await _requester.request(
_url,
'GET',
queryParams: _queryParams,
);
return Location.fromJson(_response as core.Map<core.String, core.dynamic>);
}
/// Lists information about the supported locations for this service.
///
/// Request parameters:
///
/// [name] - The resource that owns the locations collection, if applicable.
/// Value must have pattern `^projects/\[^/\]+$`.
///
/// [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 [ListLocationsResponse].
///
/// 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<ListLocationsResponse> list(
core.String name, {
core.String? filter,
core.int? pageSize,
core.String? pageToken,
core.String? $fields,
}) async {
final _queryParams = <core.String, core.List<core.String>>{
if (filter != null) 'filter': [filter],
if (pageSize != null) 'pageSize': ['${pageSize}'],
if (pageToken != null) 'pageToken': [pageToken],
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' +
commons.Escaper.ecapeVariableReserved('$name') +
'/locations';
final _response = await _requester.request(
_url,
'GET',
queryParams: _queryParams,
);
return ListLocationsResponse.fromJson(
_response as core.Map<core.String, core.dynamic>);
}
}
class ProjectsLocationsGlobalResource {
final commons.ApiRequester _requester;
ProjectsLocationsGlobalHubsResource get hubs =>
ProjectsLocationsGlobalHubsResource(_requester);
ProjectsLocationsGlobalResource(commons.ApiRequester client)
: _requester = client;
}
class ProjectsLocationsGlobalHubsResource {
final commons.ApiRequester _requester;
ProjectsLocationsGlobalHubsResource(commons.ApiRequester client)
: _requester = client;
/// Creates a new Hub in a given project and location.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [parent] - Required. The parent resource's name of the Hub.
/// Value must have pattern `^projects/\[^/\]+/locations/global$`.
///
/// [hubId] - Optional. Unique id for the Hub to create.
///
/// [requestId] - Optional. An optional request ID to identify requests.
/// Specify a unique request ID so that if you must retry your request, the
/// server will know to ignore the request if it has already been completed.
/// The server will guarantee that for at least 60 minutes since the first
/// request. For example, consider a situation where you make an initial
/// request and t he request times out. If you make the request again with the
/// same request ID, the server can check if original operation with the same
/// request ID was received, and if so, will ignore the second request. This
/// prevents clients from accidentally creating duplicate commitments. The
/// request ID must be a valid UUID with the exception that zero UUID is not
/// supported (00000000-0000-0000-0000-000000000000).
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [GoogleLongrunningOperation].
///
/// 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<GoogleLongrunningOperation> create(
Hub request,
core.String parent, {
core.String? hubId,
core.String? requestId,
core.String? $fields,
}) async {
final _body = convert.json.encode(request.toJson());
final _queryParams = <core.String, core.List<core.String>>{
if (hubId != null) 'hubId': [hubId],
if (requestId != null) 'requestId': [requestId],
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' +
commons.Escaper.ecapeVariableReserved('$parent') +
'/hubs';
final _response = await _requester.request(
_url,
'POST',
body: _body,
queryParams: _queryParams,
);
return GoogleLongrunningOperation.fromJson(
_response as core.Map<core.String, core.dynamic>);
}
/// Deletes a single Hub.
///
/// Request parameters:
///
/// [name] - Required. The name of the Hub to delete.
/// Value must have pattern
/// `^projects/\[^/\]+/locations/global/hubs/\[^/\]+$`.
///
/// [requestId] - Optional. An optional request ID to identify requests.
/// Specify a unique request ID so that if you must retry your request, the
/// server will know to ignore the request if it has already been completed.
/// The server will guarantee that for at least 60 minutes after the first
/// request. For example, consider a situation where you make an initial
/// request and t he request times out. If you make the request again with the
/// same request ID, the server can check if original operation with the same
/// request ID was received, and if so, will ignore the second request. This
/// prevents clients from accidentally creating duplicate commitments. The
/// request ID must be a valid UUID with the exception that zero UUID is not
/// supported (00000000-0000-0000-0000-000000000000).
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [GoogleLongrunningOperation].
///
/// 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<GoogleLongrunningOperation> delete(
core.String name, {
core.String? requestId,
core.String? $fields,
}) async {
final _queryParams = <core.String, core.List<core.String>>{
if (requestId != null) 'requestId': [requestId],
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' + commons.Escaper.ecapeVariableReserved('$name');
final _response = await _requester.request(
_url,
'DELETE',
queryParams: _queryParams,
);
return GoogleLongrunningOperation.fromJson(
_response as core.Map<core.String, core.dynamic>);
}
/// Gets details of a single Hub.
///
/// Request parameters:
///
/// [name] - Required. Name of the Hub resource to get.
/// Value must have pattern
/// `^projects/\[^/\]+/locations/global/hubs/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Hub].
///
/// 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<Hub> get(
core.String name, {
core.String? $fields,
}) async {
final _queryParams = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' + commons.Escaper.ecapeVariableReserved('$name');
final _response = await _requester.request(
_url,
'GET',
queryParams: _queryParams,
);
return Hub.fromJson(_response as core.Map<core.String, core.dynamic>);
}
/// Gets the access control policy for a resource.
///
/// Returns an empty policy if the resource exists and does not have a policy
/// set.
///
/// Request parameters:
///
/// [resource] - REQUIRED: The resource for which the policy is being
/// requested. See the operation documentation for the appropriate value for
/// this field.
/// Value must have pattern
/// `^projects/\[^/\]+/locations/global/hubs/\[^/\]+$`.
///
/// [options_requestedPolicyVersion] - Optional. The policy format version to
/// be returned. Valid values are 0, 1, and 3. Requests specifying an invalid
/// value will be rejected. Requests for policies with any conditional
/// bindings must specify version 3. Policies without any conditional bindings
/// may specify any valid value or leave the field unset. To learn which
/// resources support conditions in their IAM policies, see the
/// [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-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> getIamPolicy(
core.String resource, {
core.int? options_requestedPolicyVersion,
core.String? $fields,
}) async {
final _queryParams = <core.String, core.List<core.String>>{
if (options_requestedPolicyVersion != null)
'options.requestedPolicyVersion': ['${options_requestedPolicyVersion}'],
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' +
commons.Escaper.ecapeVariableReserved('$resource') +
':getIamPolicy';
final _response = await _requester.request(
_url,
'GET',
queryParams: _queryParams,
);
return Policy.fromJson(_response as core.Map<core.String, core.dynamic>);
}
/// Lists Hubs in a given project and location.
///
/// Request parameters:
///
/// [parent] - Required. The parent resource's name.
/// Value must have pattern `^projects/\[^/\]+/locations/global$`.
///
/// [filter] - A filter expression that filters the results listed in the
/// response.
///
/// [orderBy] - Sort the results by a certain order.
///
/// [pageSize] - The maximum number of results per page that should be
/// returned.
///
/// [pageToken] - The page token.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListHubsResponse].
///
/// 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<ListHubsResponse> list(
core.String parent, {
core.String? filter,
core.String? orderBy,
core.int? pageSize,
core.String? pageToken,
core.String? $fields,
}) async {
final _queryParams = <core.String, core.List<core.String>>{
if (filter != null) 'filter': [filter],
if (orderBy != null) 'orderBy': [orderBy],
if (pageSize != null) 'pageSize': ['${pageSize}'],
if (pageToken != null) 'pageToken': [pageToken],
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' +
commons.Escaper.ecapeVariableReserved('$parent') +
'/hubs';
final _response = await _requester.request(
_url,
'GET',
queryParams: _queryParams,
);
return ListHubsResponse.fromJson(
_response as core.Map<core.String, core.dynamic>);
}
/// Updates the parameters of a single Hub.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [name] - Immutable. The name of a Hub resource.
/// Value must have pattern
/// `^projects/\[^/\]+/locations/global/hubs/\[^/\]+$`.
///
/// [requestId] - Optional. An optional request ID to identify requests.
/// Specify a unique request ID so that if you must retry your request, the
/// server will know to ignore the request if it has already been completed.
/// The server will guarantee that for at least 60 minutes since the first
/// request. For example, consider a situation where you make an initial
/// request and t he request times out. If you make the request again with the
/// same request ID, the server can check if original operation with the same
/// request ID was received, and if so, will ignore the second request. This
/// prevents clients from accidentally creating duplicate commitments. The
/// request ID must be a valid UUID with the exception that zero UUID is not
/// supported (00000000-0000-0000-0000-000000000000).
///
/// [updateMask] - Optional. Field mask is used to specify the fields to be
/// overwritten in the Hub resource by the update. The fields specified in the
/// update_mask are relative to the resource, not the full request. A field
/// will be overwritten if it is in the mask. If the user does not provide a
/// mask then all fields will be overwritten.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [GoogleLongrunningOperation].
///
/// 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<GoogleLongrunningOperation> patch(
Hub request,
core.String name, {
core.String? requestId,
core.String? updateMask,
core.String? $fields,
}) async {
final _body = convert.json.encode(request.toJson());
final _queryParams = <core.String, core.List<core.String>>{
if (requestId != null) 'requestId': [requestId],
if (updateMask != null) 'updateMask': [updateMask],
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' + commons.Escaper.ecapeVariableReserved('$name');
final _response = await _requester.request(
_url,
'PATCH',
body: _body,
queryParams: _queryParams,
);
return GoogleLongrunningOperation.fromJson(
_response as core.Map<core.String, core.dynamic>);
}
/// Sets the access control policy on the specified resource.
///
/// Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`,
/// and `PERMISSION_DENIED` errors.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [resource] - REQUIRED: The resource for which the policy is being
/// specified. See the operation documentation for the appropriate value for
/// this field.
/// Value must have pattern
/// `^projects/\[^/\]+/locations/global/hubs/\[^/\]+$`.
///
/// [$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> setIamPolicy(
SetIamPolicyRequest request,
core.String resource, {
core.String? $fields,
}) async {
final _body = convert.json.encode(request.toJson());
final _queryParams = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' +
commons.Escaper.ecapeVariableReserved('$resource') +
':setIamPolicy';
final _response = await _requester.request(
_url,
'POST',
body: _body,
queryParams: _queryParams,
);
return Policy.fromJson(_response as core.Map<core.String, core.dynamic>);
}
/// Returns permissions that a caller has on the specified resource.
///
/// If the resource does not exist, this will return an empty set of
/// permissions, not a `NOT_FOUND` error. Note: This operation is designed to
/// be used for building permission-aware UIs and command-line tools, not for
/// authorization checking. This operation may "fail open" without warning.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [resource] - REQUIRED: The resource for which the policy detail is being
/// requested. See the operation documentation for the appropriate value for
/// this field.
/// Value must have pattern
/// `^projects/\[^/\]+/locations/global/hubs/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [TestIamPermissionsResponse].
///
/// 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<TestIamPermissionsResponse> testIamPermissions(
TestIamPermissionsRequest request,
core.String resource, {
core.String? $fields,
}) async {
final _body = convert.json.encode(request.toJson());
final _queryParams = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' +
commons.Escaper.ecapeVariableReserved('$resource') +
':testIamPermissions';
final _response = await _requester.request(
_url,
'POST',
body: _body,
queryParams: _queryParams,
);
return TestIamPermissionsResponse.fromJson(
_response as core.Map<core.String, core.dynamic>);
}
}
class ProjectsLocationsOperationsResource {
final commons.ApiRequester _requester;
ProjectsLocationsOperationsResource(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] - The metadata request object.
///
/// Request parameters:
///
/// [name] - The name of the operation resource to be cancelled.
/// Value must have pattern
/// `^projects/\[^/\]+/locations/\[^/\]+/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(
GoogleLongrunningCancelOperationRequest request,
core.String name, {
core.String? $fields,
}) async {
final _body = convert.json.encode(request.toJson());
final _queryParams = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' +
commons.Escaper.ecapeVariableReserved('$name') +
':cancel';
final _response = await _requester.request(
_url,
'POST',
body: _body,
queryParams: _queryParams,
);
return Empty.fromJson(_response 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
/// `^projects/\[^/\]+/locations/\[^/\]+/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,
}) async {
final _queryParams = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' + commons.Escaper.ecapeVariableReserved('$name');
final _response = await _requester.request(
_url,
'DELETE',
queryParams: _queryParams,
);
return Empty.fromJson(_response 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
/// `^projects/\[^/\]+/locations/\[^/\]+/operations/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [GoogleLongrunningOperation].
///
/// 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<GoogleLongrunningOperation> get(
core.String name, {
core.String? $fields,
}) async {
final _queryParams = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' + commons.Escaper.ecapeVariableReserved('$name');
final _response = await _requester.request(
_url,
'GET',
queryParams: _queryParams,
);
return GoogleLongrunningOperation.fromJson(
_response 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 `^projects/\[^/\]+/locations/\[^/\]+$`.
///
/// [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 [GoogleLongrunningListOperationsResponse].
///
/// 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<GoogleLongrunningListOperationsResponse> list(
core.String name, {
core.String? filter,
core.int? pageSize,
core.String? pageToken,
core.String? $fields,
}) async {
final _queryParams = <core.String, core.List<core.String>>{
if (filter != null) 'filter': [filter],
if (pageSize != null) 'pageSize': ['${pageSize}'],
if (pageToken != null) 'pageToken': [pageToken],
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' +
commons.Escaper.ecapeVariableReserved('$name') +
'/operations';
final _response = await _requester.request(
_url,
'GET',
queryParams: _queryParams,
);
return GoogleLongrunningListOperationsResponse.fromJson(
_response as core.Map<core.String, core.dynamic>);
}
}
class ProjectsLocationsPolicyBasedRoutesResource {
final commons.ApiRequester _requester;
ProjectsLocationsPolicyBasedRoutesResource(commons.ApiRequester client)
: _requester = client;
/// Gets the access control policy for a resource.
///
/// Returns an empty policy if the resource exists and does not have a policy
/// set.
///
/// Request parameters:
///
/// [resource] - REQUIRED: The resource for which the policy is being
/// requested. See the operation documentation for the appropriate value for
/// this field.
/// Value must have pattern
/// `^projects/\[^/\]+/locations/\[^/\]+/policyBasedRoutes/\[^/\]+$`.
///
/// [options_requestedPolicyVersion] - Optional. The policy format version to
/// be returned. Valid values are 0, 1, and 3. Requests specifying an invalid
/// value will be rejected. Requests for policies with any conditional
/// bindings must specify version 3. Policies without any conditional bindings
/// may specify any valid value or leave the field unset. To learn which
/// resources support conditions in their IAM policies, see the
/// [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-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> getIamPolicy(
core.String resource, {
core.int? options_requestedPolicyVersion,
core.String? $fields,
}) async {
final _queryParams = <core.String, core.List<core.String>>{
if (options_requestedPolicyVersion != null)
'options.requestedPolicyVersion': ['${options_requestedPolicyVersion}'],
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' +
commons.Escaper.ecapeVariableReserved('$resource') +
':getIamPolicy';
final _response = await _requester.request(
_url,
'GET',
queryParams: _queryParams,
);
return Policy.fromJson(_response as core.Map<core.String, core.dynamic>);
}
/// Sets the access control policy on the specified resource.
///
/// Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`,
/// and `PERMISSION_DENIED` errors.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [resource] - REQUIRED: The resource for which the policy is being
/// specified. See the operation documentation for the appropriate value for
/// this field.
/// Value must have pattern
/// `^projects/\[^/\]+/locations/\[^/\]+/policyBasedRoutes/\[^/\]+$`.
///
/// [$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> setIamPolicy(
SetIamPolicyRequest request,
core.String resource, {
core.String? $fields,
}) async {
final _body = convert.json.encode(request.toJson());
final _queryParams = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' +
commons.Escaper.ecapeVariableReserved('$resource') +
':setIamPolicy';
final _response = await _requester.request(
_url,
'POST',
body: _body,
queryParams: _queryParams,
);
return Policy.fromJson(_response as core.Map<core.String, core.dynamic>);
}
/// Returns permissions that a caller has on the specified resource.
///
/// If the resource does not exist, this will return an empty set of
/// permissions, not a `NOT_FOUND` error. Note: This operation is designed to
/// be used for building permission-aware UIs and command-line tools, not for
/// authorization checking. This operation may "fail open" without warning.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [resource] - REQUIRED: The resource for which the policy detail is being
/// requested. See the operation documentation for the appropriate value for
/// this field.
/// Value must have pattern
/// `^projects/\[^/\]+/locations/\[^/\]+/policyBasedRoutes/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [TestIamPermissionsResponse].
///
/// 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<TestIamPermissionsResponse> testIamPermissions(
TestIamPermissionsRequest request,
core.String resource, {
core.String? $fields,
}) async {
final _body = convert.json.encode(request.toJson());
final _queryParams = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' +
commons.Escaper.ecapeVariableReserved('$resource') +
':testIamPermissions';
final _response = await _requester.request(
_url,
'POST',
body: _body,
queryParams: _queryParams,
);
return TestIamPermissionsResponse.fromJson(
_response as core.Map<core.String, core.dynamic>);
}
}
class ProjectsLocationsPrivateRangesResource {
final commons.ApiRequester _requester;
ProjectsLocationsPrivateRangesResource(commons.ApiRequester client)
: _requester = client;
/// Gets the access control policy for a resource.
///
/// Returns an empty policy if the resource exists and does not have a policy
/// set.
///
/// Request parameters:
///
/// [resource] - REQUIRED: The resource for which the policy is being
/// requested. See the operation documentation for the appropriate value for
/// this field.
/// Value must have pattern
/// `^projects/\[^/\]+/locations/\[^/\]+/privateRanges/\[^/\]+$`.
///
/// [options_requestedPolicyVersion] - Optional. The policy format version to
/// be returned. Valid values are 0, 1, and 3. Requests specifying an invalid
/// value will be rejected. Requests for policies with any conditional
/// bindings must specify version 3. Policies without any conditional bindings
/// may specify any valid value or leave the field unset. To learn which
/// resources support conditions in their IAM policies, see the
/// [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-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> getIamPolicy(
core.String resource, {
core.int? options_requestedPolicyVersion,
core.String? $fields,
}) async {
final _queryParams = <core.String, core.List<core.String>>{
if (options_requestedPolicyVersion != null)
'options.requestedPolicyVersion': ['${options_requestedPolicyVersion}'],
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' +
commons.Escaper.ecapeVariableReserved('$resource') +
':getIamPolicy';
final _response = await _requester.request(
_url,
'GET',
queryParams: _queryParams,
);
return Policy.fromJson(_response as core.Map<core.String, core.dynamic>);
}
/// Sets the access control policy on the specified resource.
///
/// Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`,
/// and `PERMISSION_DENIED` errors.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [resource] - REQUIRED: The resource for which the policy is being
/// specified. See the operation documentation for the appropriate value for
/// this field.
/// Value must have pattern
/// `^projects/\[^/\]+/locations/\[^/\]+/privateRanges/\[^/\]+$`.
///
/// [$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> setIamPolicy(
SetIamPolicyRequest request,
core.String resource, {
core.String? $fields,
}) async {
final _body = convert.json.encode(request.toJson());
final _queryParams = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' +
commons.Escaper.ecapeVariableReserved('$resource') +
':setIamPolicy';
final _response = await _requester.request(
_url,
'POST',
body: _body,
queryParams: _queryParams,
);
return Policy.fromJson(_response as core.Map<core.String, core.dynamic>);
}
/// Returns permissions that a caller has on the specified resource.
///
/// If the resource does not exist, this will return an empty set of
/// permissions, not a `NOT_FOUND` error. Note: This operation is designed to
/// be used for building permission-aware UIs and command-line tools, not for
/// authorization checking. This operation may "fail open" without warning.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [resource] - REQUIRED: The resource for which the policy detail is being
/// requested. See the operation documentation for the appropriate value for
/// this field.
/// Value must have pattern
/// `^projects/\[^/\]+/locations/\[^/\]+/privateRanges/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [TestIamPermissionsResponse].
///
/// 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<TestIamPermissionsResponse> testIamPermissions(
TestIamPermissionsRequest request,
core.String resource, {
core.String? $fields,
}) async {
final _body = convert.json.encode(request.toJson());
final _queryParams = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' +
commons.Escaper.ecapeVariableReserved('$resource') +
':testIamPermissions';
final _response = await _requester.request(
_url,
'POST',
body: _body,
queryParams: _queryParams,
);
return TestIamPermissionsResponse.fromJson(
_response as core.Map<core.String, core.dynamic>);
}
}
class ProjectsLocationsSpokesResource {
final commons.ApiRequester _requester;
ProjectsLocationsSpokesResource(commons.ApiRequester client)
: _requester = client;
/// Creates a new Spoke in a given project and location.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [parent] - Required. The parent's resource name of the Spoke.
/// Value must have pattern `^projects/\[^/\]+/locations/\[^/\]+$`.
///
/// [requestId] - Optional. An optional request ID to identify requests.
/// Specify a unique request ID so that if you must retry your request, the
/// server will know to ignore the request if it has already been completed.
/// The server will guarantee that for at least 60 minutes since the first
/// request. For example, consider a situation where you make an initial
/// request and t he request times out. If you make the request again with the
/// same request ID, the server can check if original operation with the same
/// request ID was received, and if so, will ignore the second request. This
/// prevents clients from accidentally creating duplicate commitments. The
/// request ID must be a valid UUID with the exception that zero UUID is not
/// supported (00000000-0000-0000-0000-000000000000).
///
/// [spokeId] - Optional. Unique id for the Spoke to create.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [GoogleLongrunningOperation].
///
/// 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<GoogleLongrunningOperation> create(
Spoke request,
core.String parent, {
core.String? requestId,
core.String? spokeId,
core.String? $fields,
}) async {
final _body = convert.json.encode(request.toJson());
final _queryParams = <core.String, core.List<core.String>>{
if (requestId != null) 'requestId': [requestId],
if (spokeId != null) 'spokeId': [spokeId],
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' +
commons.Escaper.ecapeVariableReserved('$parent') +
'/spokes';
final _response = await _requester.request(
_url,
'POST',
body: _body,
queryParams: _queryParams,
);
return GoogleLongrunningOperation.fromJson(
_response as core.Map<core.String, core.dynamic>);
}
/// Deletes a single Spoke.
///
/// Request parameters:
///
/// [name] - Required. The name of the Spoke to delete.
/// Value must have pattern
/// `^projects/\[^/\]+/locations/\[^/\]+/spokes/\[^/\]+$`.
///
/// [requestId] - Optional. An optional request ID to identify requests.
/// Specify a unique request ID so that if you must retry your request, the
/// server will know to ignore the request if it has already been completed.
/// The server will guarantee that for at least 60 minutes after the first
/// request. For example, consider a situation where you make an initial
/// request and t he request times out. If you make the request again with the
/// same request ID, the server can check if original operation with the same
/// request ID was received, and if so, will ignore the second request. This
/// prevents clients from accidentally creating duplicate commitments. The
/// request ID must be a valid UUID with the exception that zero UUID is not
/// supported (00000000-0000-0000-0000-000000000000).
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [GoogleLongrunningOperation].
///
/// 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<GoogleLongrunningOperation> delete(
core.String name, {
core.String? requestId,
core.String? $fields,
}) async {
final _queryParams = <core.String, core.List<core.String>>{
if (requestId != null) 'requestId': [requestId],
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' + commons.Escaper.ecapeVariableReserved('$name');
final _response = await _requester.request(
_url,
'DELETE',
queryParams: _queryParams,
);
return GoogleLongrunningOperation.fromJson(
_response as core.Map<core.String, core.dynamic>);
}
/// Gets details of a single Spoke.
///
/// Request parameters:
///
/// [name] - Required. The name of Spoke resource.
/// Value must have pattern
/// `^projects/\[^/\]+/locations/\[^/\]+/spokes/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [Spoke].
///
/// 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<Spoke> get(
core.String name, {
core.String? $fields,
}) async {
final _queryParams = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' + commons.Escaper.ecapeVariableReserved('$name');
final _response = await _requester.request(
_url,
'GET',
queryParams: _queryParams,
);
return Spoke.fromJson(_response as core.Map<core.String, core.dynamic>);
}
/// Gets the access control policy for a resource.
///
/// Returns an empty policy if the resource exists and does not have a policy
/// set.
///
/// Request parameters:
///
/// [resource] - REQUIRED: The resource for which the policy is being
/// requested. See the operation documentation for the appropriate value for
/// this field.
/// Value must have pattern
/// `^projects/\[^/\]+/locations/\[^/\]+/spokes/\[^/\]+$`.
///
/// [options_requestedPolicyVersion] - Optional. The policy format version to
/// be returned. Valid values are 0, 1, and 3. Requests specifying an invalid
/// value will be rejected. Requests for policies with any conditional
/// bindings must specify version 3. Policies without any conditional bindings
/// may specify any valid value or leave the field unset. To learn which
/// resources support conditions in their IAM policies, see the
/// [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-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> getIamPolicy(
core.String resource, {
core.int? options_requestedPolicyVersion,
core.String? $fields,
}) async {
final _queryParams = <core.String, core.List<core.String>>{
if (options_requestedPolicyVersion != null)
'options.requestedPolicyVersion': ['${options_requestedPolicyVersion}'],
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' +
commons.Escaper.ecapeVariableReserved('$resource') +
':getIamPolicy';
final _response = await _requester.request(
_url,
'GET',
queryParams: _queryParams,
);
return Policy.fromJson(_response as core.Map<core.String, core.dynamic>);
}
/// Lists Spokes in a given project and location.
///
/// Request parameters:
///
/// [parent] - Required. The parent's resource name.
/// Value must have pattern `^projects/\[^/\]+/locations/\[^/\]+$`.
///
/// [filter] - A filter expression that filters the results listed in the
/// response.
///
/// [orderBy] - Sort the results by a certain order.
///
/// [pageSize] - The maximum number of results per page that should be
/// returned.
///
/// [pageToken] - The page token.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [ListSpokesResponse].
///
/// 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<ListSpokesResponse> list(
core.String parent, {
core.String? filter,
core.String? orderBy,
core.int? pageSize,
core.String? pageToken,
core.String? $fields,
}) async {
final _queryParams = <core.String, core.List<core.String>>{
if (filter != null) 'filter': [filter],
if (orderBy != null) 'orderBy': [orderBy],
if (pageSize != null) 'pageSize': ['${pageSize}'],
if (pageToken != null) 'pageToken': [pageToken],
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' +
commons.Escaper.ecapeVariableReserved('$parent') +
'/spokes';
final _response = await _requester.request(
_url,
'GET',
queryParams: _queryParams,
);
return ListSpokesResponse.fromJson(
_response as core.Map<core.String, core.dynamic>);
}
/// Updates the parameters of a single Spoke.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [name] - Immutable. The name of a Spoke resource.
/// Value must have pattern
/// `^projects/\[^/\]+/locations/\[^/\]+/spokes/\[^/\]+$`.
///
/// [requestId] - Optional. An optional request ID to identify requests.
/// Specify a unique request ID so that if you must retry your request, the
/// server will know to ignore the request if it has already been completed.
/// The server will guarantee that for at least 60 minutes since the first
/// request. For example, consider a situation where you make an initial
/// request and t he request times out. If you make the request again with the
/// same request ID, the server can check if original operation with the same
/// request ID was received, and if so, will ignore the second request. This
/// prevents clients from accidentally creating duplicate commitments. The
/// request ID must be a valid UUID with the exception that zero UUID is not
/// supported (00000000-0000-0000-0000-000000000000).
///
/// [updateMask] - Optional. Field mask is used to specify the fields to be
/// overwritten in the Spoke resource by the update. The fields specified in
/// the update_mask are relative to the resource, not the full request. A
/// field will be overwritten if it is in the mask. If the user does not
/// provide a mask then all fields will be overwritten.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [GoogleLongrunningOperation].
///
/// 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<GoogleLongrunningOperation> patch(
Spoke request,
core.String name, {
core.String? requestId,
core.String? updateMask,
core.String? $fields,
}) async {
final _body = convert.json.encode(request.toJson());
final _queryParams = <core.String, core.List<core.String>>{
if (requestId != null) 'requestId': [requestId],
if (updateMask != null) 'updateMask': [updateMask],
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' + commons.Escaper.ecapeVariableReserved('$name');
final _response = await _requester.request(
_url,
'PATCH',
body: _body,
queryParams: _queryParams,
);
return GoogleLongrunningOperation.fromJson(
_response as core.Map<core.String, core.dynamic>);
}
/// Sets the access control policy on the specified resource.
///
/// Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`,
/// and `PERMISSION_DENIED` errors.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [resource] - REQUIRED: The resource for which the policy is being
/// specified. See the operation documentation for the appropriate value for
/// this field.
/// Value must have pattern
/// `^projects/\[^/\]+/locations/\[^/\]+/spokes/\[^/\]+$`.
///
/// [$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> setIamPolicy(
SetIamPolicyRequest request,
core.String resource, {
core.String? $fields,
}) async {
final _body = convert.json.encode(request.toJson());
final _queryParams = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' +
commons.Escaper.ecapeVariableReserved('$resource') +
':setIamPolicy';
final _response = await _requester.request(
_url,
'POST',
body: _body,
queryParams: _queryParams,
);
return Policy.fromJson(_response as core.Map<core.String, core.dynamic>);
}
/// Returns permissions that a caller has on the specified resource.
///
/// If the resource does not exist, this will return an empty set of
/// permissions, not a `NOT_FOUND` error. Note: This operation is designed to
/// be used for building permission-aware UIs and command-line tools, not for
/// authorization checking. This operation may "fail open" without warning.
///
/// [request] - The metadata request object.
///
/// Request parameters:
///
/// [resource] - REQUIRED: The resource for which the policy detail is being
/// requested. See the operation documentation for the appropriate value for
/// this field.
/// Value must have pattern
/// `^projects/\[^/\]+/locations/\[^/\]+/spokes/\[^/\]+$`.
///
/// [$fields] - Selector specifying which fields to include in a partial
/// response.
///
/// Completes with a [TestIamPermissionsResponse].
///
/// 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<TestIamPermissionsResponse> testIamPermissions(
TestIamPermissionsRequest request,
core.String resource, {
core.String? $fields,
}) async {
final _body = convert.json.encode(request.toJson());
final _queryParams = <core.String, core.List<core.String>>{
if ($fields != null) 'fields': [$fields],
};
final _url = 'v1alpha1/' +
commons.Escaper.ecapeVariableReserved('$resource') +
':testIamPermissions';
final _response = await _requester.request(
_url,
'POST',
body: _body,
queryParams: _queryParams,
);
return TestIamPermissionsResponse.fromJson(
_response as core.Map<core.String, core.dynamic>);
}
}
/// The allowed types for \[VALUE\] in a `[KEY]:[VALUE]` attribute.
class AttributeValue {
/// A Boolean value represented by `true` or `false`.
core.bool? boolValue;
/// A 64-bit signed integer.
core.String? intValue;
/// A string up to 256 bytes long.
TruncatableString? stringValue;
AttributeValue();
AttributeValue.fromJson(core.Map _json) {
if (_json.containsKey('boolValue')) {
boolValue = _json['boolValue'] as core.bool;
}
if (_json.containsKey('intValue')) {
intValue = _json['intValue'] as core.String;
}
if (_json.containsKey('stringValue')) {
stringValue = TruncatableString.fromJson(
_json['stringValue'] as core.Map<core.String, core.dynamic>);
}
}
core.Map<core.String, core.Object?> toJson() => {
if (boolValue != null) 'boolValue': boolValue!,
if (intValue != null) 'intValue': intValue!,
if (stringValue != null) 'stringValue': stringValue!.toJson(),
};
}
/// A set of attributes, each in the format `[KEY]:[VALUE]`.
class Attributes {
/// The set of attributes.
///
/// Each attribute's key can be up to 128 bytes long. The value can be a
/// string up to 256 bytes, a signed 64-bit integer, or the Boolean values
/// `true` and `false`. For example: "/instance_id": "my-instance"
/// "/http/user_agent": "" "/http/request_bytes": 300 "abc.com/myattribute":
/// true
core.Map<core.String, AttributeValue>? attributeMap;
/// The number of attributes that were discarded.
///
/// Attributes can be discarded because their keys are too long or because
/// there are too many attributes. If this value is 0 then all attributes are
/// valid.
core.int? droppedAttributesCount;
Attributes();
Attributes.fromJson(core.Map _json) {
if (_json.containsKey('attributeMap')) {
attributeMap = (_json['attributeMap'] as core.Map)
.cast<core.String, core.Map<core.String, core.Object?>>()
.map(
(key, item) => core.MapEntry(
key,
AttributeValue.fromJson(
item as core.Map<core.String, core.dynamic>),
),
);
}
if (_json.containsKey('droppedAttributesCount')) {
droppedAttributesCount = _json['droppedAttributesCount'] as core.int;
}
}
core.Map<core.String, core.Object?> toJson() => {
if (attributeMap != null)
'attributeMap': attributeMap!
.map((key, item) => core.MapEntry(key, item.toJson())),
if (droppedAttributesCount != null)
'droppedAttributesCount': droppedAttributesCount!,
};
}
/// Specifies the audit configuration for a service.
///
/// The configuration determines which permission types are logged, and what
/// identities, if any, are exempted from logging. An AuditConfig must have one
/// or more AuditLogConfigs. If there are AuditConfigs for both `allServices`
/// and a specific service, the union of the two AuditConfigs is used for that
/// service: the log_types specified in each AuditConfig are enabled, and the
/// exempted_members in each AuditLogConfig are exempted. Example Policy with
/// multiple AuditConfigs: { "audit_configs": \[ { "service": "allServices",
/// "audit_log_configs": \[ { "log_type": "DATA_READ", "exempted_members": \[
/// "user:jose@example.com" \] }, { "log_type": "DATA_WRITE" }, { "log_type":
/// "ADMIN_READ" } \] }, { "service": "sampleservice.googleapis.com",
/// "audit_log_configs": \[ { "log_type": "DATA_READ" }, { "log_type":
/// "DATA_WRITE", "exempted_members": \[ "user:aliya@example.com" \] } \] } \] }
/// For sampleservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ
/// logging. It also exempts jose@example.com from DATA_READ logging, and
/// aliya@example.com from DATA_WRITE logging.
class AuditConfig {
/// The configuration for logging of each type of permission.
core.List<AuditLogConfig>? auditLogConfigs;
/// Specifies a service that will be enabled for audit logging.
///
/// For example, `storage.googleapis.com`, `cloudsql.googleapis.com`.
/// `allServices` is a special value that covers all services.
core.String? service;
AuditConfig();
AuditConfig.fromJson(core.Map _json) {
if (_json.containsKey('auditLogConfigs')) {
auditLogConfigs = (_json['auditLogConfigs'] as core.List)
.map<AuditLogConfig>((value) => AuditLogConfig.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('service')) {
service = _json['service'] as core.String;
}
}
core.Map<core.String, core.Object?> toJson() => {
if (auditLogConfigs != null)
'auditLogConfigs':
auditLogConfigs!.map((value) => value.toJson()).toList(),
if (service != null) 'service': service!,
};
}
/// Provides the configuration for logging a type of permissions.
///
/// Example: { "audit_log_configs": \[ { "log_type": "DATA_READ",
/// "exempted_members": \[ "user:jose@example.com" \] }, { "log_type":
/// "DATA_WRITE" } \] } This enables 'DATA_READ' and 'DATA_WRITE' logging, while
/// exempting jose@example.com from DATA_READ logging.
class AuditLogConfig {
/// Specifies the identities that do not cause logging for this type of
/// permission.
///
/// Follows the same format of Binding.members.
core.List<core.String>? exemptedMembers;
/// The log type that this config enables.
/// Possible string values are:
/// - "LOG_TYPE_UNSPECIFIED" : Default case. Should never be this.
/// - "ADMIN_READ" : Admin reads. Example: CloudIAM getIamPolicy
/// - "DATA_WRITE" : Data writes. Example: CloudSQL Users create
/// - "DATA_READ" : Data reads. Example: CloudSQL Users list
core.String? logType;
AuditLogConfig();
AuditLogConfig.fromJson(core.Map _json) {
if (_json.containsKey('exemptedMembers')) {
exemptedMembers = (_json['exemptedMembers'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('logType')) {
logType = _json['logType'] as core.String;
}
}
core.Map<core.String, core.Object?> toJson() => {
if (exemptedMembers != null) 'exemptedMembers': exemptedMembers!,
if (logType != null) 'logType': logType!,
};
}
/// Message for reporting billing requests through Eventstream.
class BillingView {
/// Billing requests to be reported for cloud.eventstream.v2.ResourceEvent
/// Each request contains billing operations to be reported under a service
/// name.
///
/// See go/billing-view-construction for documentation on constructing billing
/// view report requests.
core.List<ReportRequest>? reportRequests;
BillingView();
BillingView.fromJson(core.Map _json) {
if (_json.containsKey('reportRequests')) {
reportRequests = (_json['reportRequests'] as core.List)
.map<ReportRequest>((value) => ReportRequest.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
}
core.Map<core.String, core.Object?> toJson() => {
if (reportRequests != null)
'reportRequests':
reportRequests!.map((value) => value.toJson()).toList(),
};
}
/// Associates `members` with a `role`.
class Binding {
/// The condition that is associated with this binding.
///
/// If the condition evaluates to `true`, then this binding applies to the
/// current request. If the condition evaluates to `false`, then this binding
/// does not apply to the current request. However, a different role binding
/// might grant the same role to one or more of the members in this binding.
/// To learn which resources support conditions in their IAM policies, see the
/// [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
Expr? condition;
/// Specifies the identities requesting access for a Cloud Platform resource.
///
/// `members` can have the following values: * `allUsers`: A special
/// identifier that represents anyone who is on the internet; with or without
/// a Google account. * `allAuthenticatedUsers`: A special identifier that
/// represents anyone who is authenticated with a Google account or a service
/// account. * `user:{emailid}`: An email address that represents a specific
/// Google account. For example, `alice@example.com` . *
/// `serviceAccount:{emailid}`: An email address that represents a service
/// account. For example, `my-other-app@appspot.gserviceaccount.com`. *
/// `group:{emailid}`: An email address that represents a Google group. For
/// example, `admins@example.com`. * `deleted:user:{emailid}?uid={uniqueid}`:
/// An email address (plus unique identifier) representing a user that has
/// been recently deleted. For example,
/// `alice@example.com?uid=123456789012345678901`. If the user is recovered,
/// this value reverts to `user:{emailid}` and the recovered user retains the
/// role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`:
/// An email address (plus unique identifier) representing a service account
/// that has been recently deleted. For example,
/// `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If
/// the service account is undeleted, this value reverts to
/// `serviceAccount:{emailid}` and the undeleted service account retains the
/// role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email
/// address (plus unique identifier) representing a Google group that has been
/// recently deleted. For example,
/// `admins@example.com?uid=123456789012345678901`. If the group is recovered,
/// this value reverts to `group:{emailid}` and the recovered group retains
/// the role in the binding. * `domain:{domain}`: The G Suite domain (primary)
/// that represents all the users of that domain. For example, `google.com` or
/// `example.com`.
core.List<core.String>? members;
/// Role that is assigned to `members`.
///
/// For example, `roles/viewer`, `roles/editor`, or `roles/owner`.
core.String? role;
Binding();
Binding.fromJson(core.Map _json) {
if (_json.containsKey('condition')) {
condition = Expr.fromJson(
_json['condition'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('members')) {
members = (_json['members'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('role')) {
role = _json['role'] as core.String;
}
}
core.Map<core.String, core.Object?> toJson() => {
if (condition != null) 'condition': condition!.toJson(),
if (members != null) 'members': members!,
if (role != null) 'role': role!,
};
}
/// Distribution represents a frequency distribution of double-valued sample
/// points.
///
/// It contains the size of the population of sample points plus additional
/// optional information: - the arithmetic mean of the samples - the minimum and
/// maximum of the samples - the sum-squared-deviation of the samples, used to
/// compute variance - a histogram of the values of the sample points
class Distribution {
/// The number of samples in each histogram bucket.
///
/// \`bucket_counts\` are optional. If present, they must sum to the \`count\`
/// value. The buckets are defined below in \`bucket_option\`. There are N
/// buckets. \`bucket_counts\[0\]\` is the number of samples in the underflow
/// bucket. \`bucket_counts\[1\]\` to \`bucket_counts\[N-1\]\` are the numbers
/// of samples in each of the finite buckets. And \`bucket_counts\[N\] is the
/// number of samples in the overflow bucket. See the comments of
/// \`bucket_option\` below for more details. Any suffix of trailing zeros may
/// be omitted.
core.List<core.String>? bucketCounts;
/// The total number of samples in the distribution.
///
/// Must be >= 0.
core.String? count;
/// Example points.
///
/// Must be in increasing order of `value` field.
core.List<Exemplar>? exemplars;
/// Buckets with arbitrary user-provided width.
ExplicitBuckets? explicitBuckets;
/// Buckets with exponentially growing width.
ExponentialBuckets? exponentialBuckets;
/// Buckets with constant width.
LinearBuckets? linearBuckets;
/// The maximum of the population of values.
///
/// Ignored if `count` is zero.
core.double? maximum;
/// The arithmetic mean of the samples in the distribution.
///
/// If `count` is zero then this field must be zero.
core.double? mean;
/// The minimum of the population of values.
///
/// Ignored if `count` is zero.
core.double? minimum;
/// The sum of squared deviations from the mean: Sum\[i=1..count\]((x_i -
/// mean)^2) where each x_i is a sample values.
///
/// If `count` is zero then this field must be zero, otherwise validation of
/// the request fails.
core.double? sumOfSquaredDeviation;
Distribution();
Distribution.fromJson(core.Map _json) {
if (_json.containsKey('bucketCounts')) {
bucketCounts = (_json['bucketCounts'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('count')) {
count = _json['count'] as core.String;
}
if (_json.containsKey('exemplars')) {
exemplars = (_json['exemplars'] as core.List)
.map<Exemplar>((value) =>
Exemplar.fromJson(value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('explicitBuckets')) {
explicitBuckets = ExplicitBuckets.fromJson(
_json['explicitBuckets'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('exponentialBuckets')) {
exponentialBuckets = ExponentialBuckets.fromJson(
_json['exponentialBuckets'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('linearBuckets')) {
linearBuckets = LinearBuckets.fromJson(
_json['linearBuckets'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('maximum')) {
maximum = (_json['maximum'] as core.num).toDouble();
}
if (_json.containsKey('mean')) {
mean = (_json['mean'] as core.num).toDouble();
}
if (_json.containsKey('minimum')) {
minimum = (_json['minimum'] as core.num).toDouble();
}
if (_json.containsKey('sumOfSquaredDeviation')) {
sumOfSquaredDeviation =
(_json['sumOfSquaredDeviation'] as core.num).toDouble();
}
}
core.Map<core.String, core.Object?> toJson() => {
if (bucketCounts != null) 'bucketCounts': bucketCounts!,
if (count != null) 'count': count!,
if (exemplars != null)
'exemplars': exemplars!.map((value) => value.toJson()).toList(),
if (explicitBuckets != null)
'explicitBuckets': explicitBuckets!.toJson(),
if (exponentialBuckets != null)
'exponentialBuckets': exponentialBuckets!.toJson(),
if (linearBuckets != null) 'linearBuckets': linearBuckets!.toJson(),
if (maximum != null) 'maximum': maximum!,
if (mean != null) 'mean': mean!,
if (minimum != null) 'minimum': minimum!,
if (sumOfSquaredDeviation != null)
'sumOfSquaredDeviation': sumOfSquaredDeviation!,
};
}
/// 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() => {};
}
/// Exemplars are example points that may be used to annotate aggregated
/// distribution values.
///
/// They are metadata that gives information about a particular value added to a
/// Distribution bucket, such as a trace ID that was active when a value was
/// added. They may contain further information, such as a example values and
/// timestamps, origin, etc.
class Exemplar {
/// Contextual information about the example value.
///
/// Examples are: Trace: type.googleapis.com/google.monitoring.v3.SpanContext
/// Literal string: type.googleapis.com/google.protobuf.StringValue Labels
/// dropped during aggregation:
/// type.googleapis.com/google.monitoring.v3.DroppedLabels There may be only a
/// single attachment of any given message type in a single exemplar, and this
/// is enforced by the system.
///
/// 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>>? attachments;
/// The observation (sampling) time of the above value.
core.String? timestamp;
/// Value of the exemplar point.
///
/// This value determines to which bucket the exemplar belongs.
core.double? value;
Exemplar();
Exemplar.fromJson(core.Map _json) {
if (_json.containsKey('attachments')) {
attachments = (_json['attachments'] 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('timestamp')) {
timestamp = _json['timestamp'] as core.String;
}
if (_json.containsKey('value')) {
value = (_json['value'] as core.num).toDouble();
}
}
core.Map<core.String, core.Object?> toJson() => {
if (attachments != null) 'attachments': attachments!,
if (timestamp != null) 'timestamp': timestamp!,
if (value != null) 'value': value!,
};
}
/// Describing buckets with arbitrary user-provided width.
class ExplicitBuckets {
/// 'bound' is a list of strictly increasing boundaries between buckets.
///
/// Note that a list of length N-1 defines N buckets because of fenceposting.
/// See comments on `bucket_options` for details. The i'th finite bucket
/// covers the interval \[bound\[i-1\], bound\[i\]) where i ranges from 1 to
/// bound_size() - 1. Note that there are no finite buckets at all if 'bound'
/// only contains a single element; in that special case the single bound
/// defines the boundary between the underflow and overflow buckets. bucket
/// number lower bound upper bound i == 0 (underflow) -inf bound\[i\] 0 < i <
/// bound_size() bound\[i-1\] bound\[i\] i == bound_size() (overflow)
/// bound\[i-1\] +inf
core.List<core.double>? bounds;
ExplicitBuckets();
ExplicitBuckets.fromJson(core.Map _json) {
if (_json.containsKey('bounds')) {
bounds = (_json['bounds'] as core.List)
.map<core.double>((value) => (value as core.num).toDouble())
.toList();
}
}
core.Map<core.String, core.Object?> toJson() => {
if (bounds != null) 'bounds': bounds!,
};
}
/// Describing buckets with exponentially growing width.
class ExponentialBuckets {
/// The i'th exponential bucket covers the interval \[scale *
/// growth_factor^(i-1), scale * growth_factor^i) where i ranges from 1 to
/// num_finite_buckets inclusive.
///
/// Must be larger than 1.0.
core.double? growthFactor;
/// The number of finite buckets.
///
/// With the underflow and overflow buckets, the total number of buckets is
/// `num_finite_buckets` + 2. See comments on `bucket_options` for details.
core.int? numFiniteBuckets;
/// The i'th exponential bucket covers the interval \[scale *
/// growth_factor^(i-1), scale * growth_factor^i) where i ranges from 1 to
/// num_finite_buckets inclusive.
///
/// Must be > 0.
core.double? scale;
ExponentialBuckets();
ExponentialBuckets.fromJson(core.Map _json) {
if (_json.containsKey('growthFactor')) {
growthFactor = (_json['growthFactor'] as core.num).toDouble();
}
if (_json.containsKey('numFiniteBuckets')) {
numFiniteBuckets = _json['numFiniteBuckets'] as core.int;
}
if (_json.containsKey('scale')) {
scale = (_json['scale'] as core.num).toDouble();
}
}
core.Map<core.String, core.Object?> toJson() => {
if (growthFactor != null) 'growthFactor': growthFactor!,
if (numFiniteBuckets != null) 'numFiniteBuckets': numFiniteBuckets!,
if (scale != null) 'scale': scale!,
};
}
/// Represents a textual expression in the Common Expression Language (CEL)
/// syntax.
///
/// CEL is a C-like expression language. The syntax and semantics of CEL are
/// documented at https://github.com/google/cel-spec. Example (Comparison):
/// title: "Summary size limit" description: "Determines if a summary is less
/// than 100 chars" expression: "document.summary.size() < 100" Example
/// (Equality): title: "Requestor is owner" description: "Determines if
/// requestor is the document owner" expression: "document.owner ==
/// request.auth.claims.email" Example (Logic): title: "Public documents"
/// description: "Determine whether the document should be publicly visible"
/// expression: "document.type != 'private' && document.type != 'internal'"
/// Example (Data Manipulation): title: "Notification string" description:
/// "Create a notification string with a timestamp." expression: "'New message
/// received at ' + string(document.create_time)" The exact variables and
/// functions that may be referenced within an expression are determined by the
/// service that evaluates it. See the service documentation for additional
/// information.
class Expr {
/// Description of the expression.
///
/// This is a longer text which describes the expression, e.g. when hovered
/// over it in a UI.
///
/// Optional.
core.String? description;
/// Textual representation of an expression in Common Expression Language
/// syntax.
core.String? expression;
/// String indicating the location of the expression for error reporting, e.g.
/// a file name and a position in the file.
///
/// Optional.
core.String? location;
/// Title for the expression, i.e. a short string describing its purpose.
///
/// This can be used e.g. in UIs which allow to enter the expression.
///
/// Optional.
core.String? title;
Expr();
Expr.fromJson(core.Map _json) {
if (_json.containsKey('description')) {
description = _json['description'] as core.String;
}
if (_json.containsKey('expression')) {
expression = _json['expression'] as core.String;
}
if (_json.containsKey('location')) {
location = _json['location'] as core.String;
}
if (_json.containsKey('title')) {
title = _json['title'] as core.String;
}
}
core.Map<core.String, core.Object?> toJson() => {
if (description != null) 'description': description!,
if (expression != null) 'expression': expression!,
if (location != null) 'location': location!,
if (title != null) 'title': title!,
};
}
/// The request message for Operations.CancelOperation.
class GoogleLongrunningCancelOperationRequest {
GoogleLongrunningCancelOperationRequest();
GoogleLongrunningCancelOperationRequest.fromJson(
// ignore: avoid_unused_constructor_parameters
core.Map _json);
core.Map<core.String, core.Object?> toJson() => {};
}
/// The response message for Operations.ListOperations.
class GoogleLongrunningListOperationsResponse {
/// The standard List next-page token.
core.String? nextPageToken;
/// A list of operations that matches the specified filter in the request.
core.List<GoogleLongrunningOperation>? operations;
GoogleLongrunningListOperationsResponse();
GoogleLongrunningListOperationsResponse.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<GoogleLongrunningOperation>((value) =>
GoogleLongrunningOperation.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
}
core.Map<core.String, core.Object?> toJson() => {
if (nextPageToken != null) 'nextPageToken': nextPageToken!,
if (operations != null)
'operations': operations!.map((value) => value.toJson()).toList(),
};
}
/// This resource represents a long-running operation that is the result of a
/// network API call.
class GoogleLongrunningOperation {
/// 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.
GoogleRpcStatus? 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;
GoogleLongrunningOperation();
GoogleLongrunningOperation.fromJson(core.Map _json) {
if (_json.containsKey('done')) {
done = _json['done'] as core.bool;
}
if (_json.containsKey('error')) {
error = GoogleRpcStatus.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() => {
if (done != null) 'done': done!,
if (error != null) 'error': error!.toJson(),
if (metadata != null) 'metadata': metadata!,
if (name != null) 'name': name!,
if (response != null) 'response': response!,
};
}
/// 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 GoogleRpcStatus {
/// 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;
GoogleRpcStatus();
GoogleRpcStatus.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() => {
if (code != null) 'code': code!,
if (details != null) 'details': details!,
if (message != null) 'message': message!,
};
}
/// A common proto for logging HTTP requests.
///
/// Only contains semantics defined by the HTTP specification. Product-specific
/// logging information MUST be defined in a separate message.
class HttpRequest {
/// The number of HTTP response bytes inserted into cache.
///
/// Set only when a cache fill was attempted.
core.String? cacheFillBytes;
/// Whether or not an entity was served from cache (with or without
/// validation).
core.bool? cacheHit;
/// Whether or not a cache lookup was attempted.
core.bool? cacheLookup;
/// Whether or not the response was validated with the origin server before
/// being served from cache.
///
/// This field is only meaningful if `cache_hit` is True.
core.bool? cacheValidatedWithOriginServer;
/// The request processing latency on the server, from the time the request
/// was received until the response was sent.
core.String? latency;
/// Protocol used for the request.
///
/// Examples: "HTTP/1.1", "HTTP/2", "websocket"
core.String? protocol;
/// The referer URL of the request, as defined in
/// [HTTP/1.1 Header Field Definitions](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html).
core.String? referer;
/// The IP address (IPv4 or IPv6) of the client that issued the HTTP request.
///
/// Examples: `"192.168.1.1"`, `"FE80::0202:B3FF:FE1E:8329"`.
core.String? remoteIp;
/// The request method.
///
/// Examples: `"GET"`, `"HEAD"`, `"PUT"`, `"POST"`.
core.String? requestMethod;
/// The size of the HTTP request message in bytes, including the request
/// headers and the request body.
core.String? requestSize;
/// The scheme (http, https), the host name, the path, and the query portion
/// of the URL that was requested.
///
/// Example: `"http://example.com/some/info?color=red"`.
core.String? requestUrl;
/// The size of the HTTP response message sent back to the client, in bytes,
/// including the response headers and the response body.
core.String? responseSize;
/// The IP address (IPv4 or IPv6) of the origin server that the request was
/// sent to.
core.String? serverIp;
/// The response code indicating the status of the response.
///
/// Examples: 200, 404.
core.int? status;
/// The user agent sent by the client.
///
/// Example: `"Mozilla/4.0 (compatible; MSIE 6.0; Windows 98; Q312461; .NET
/// CLR 1.0.3705)"`.
core.String? userAgent;
HttpRequest();
HttpRequest.fromJson(core.Map _json) {
if (_json.containsKey('cacheFillBytes')) {
cacheFillBytes = _json['cacheFillBytes'] as core.String;
}
if (_json.containsKey('cacheHit')) {
cacheHit = _json['cacheHit'] as core.bool;
}
if (_json.containsKey('cacheLookup')) {
cacheLookup = _json['cacheLookup'] as core.bool;
}
if (_json.containsKey('cacheValidatedWithOriginServer')) {
cacheValidatedWithOriginServer =
_json['cacheValidatedWithOriginServer'] as core.bool;
}
if (_json.containsKey('latency')) {
latency = _json['latency'] as core.String;
}
if (_json.containsKey('protocol')) {
protocol = _json['protocol'] as core.String;
}
if (_json.containsKey('referer')) {
referer = _json['referer'] as core.String;
}
if (_json.containsKey('remoteIp')) {
remoteIp = _json['remoteIp'] as core.String;
}
if (_json.containsKey('requestMethod')) {
requestMethod = _json['requestMethod'] as core.String;
}
if (_json.containsKey('requestSize')) {
requestSize = _json['requestSize'] as core.String;
}
if (_json.containsKey('requestUrl')) {
requestUrl = _json['requestUrl'] as core.String;
}
if (_json.containsKey('responseSize')) {
responseSize = _json['responseSize'] as core.String;
}
if (_json.containsKey('serverIp')) {
serverIp = _json['serverIp'] as core.String;
}
if (_json.containsKey('status')) {
status = _json['status'] as core.int;
}
if (_json.containsKey('userAgent')) {
userAgent = _json['userAgent'] as core.String;
}
}
core.Map<core.String, core.Object?> toJson() => {
if (cacheFillBytes != null) 'cacheFillBytes': cacheFillBytes!,
if (cacheHit != null) 'cacheHit': cacheHit!,
if (cacheLookup != null) 'cacheLookup': cacheLookup!,
if (cacheValidatedWithOriginServer != null)
'cacheValidatedWithOriginServer': cacheValidatedWithOriginServer!,
if (latency != null) 'latency': latency!,
if (protocol != null) 'protocol': protocol!,
if (referer != null) 'referer': referer!,
if (remoteIp != null) 'remoteIp': remoteIp!,
if (requestMethod != null) 'requestMethod': requestMethod!,
if (requestSize != null) 'requestSize': requestSize!,
if (requestUrl != null) 'requestUrl': requestUrl!,
if (responseSize != null) 'responseSize': responseSize!,
if (serverIp != null) 'serverIp': serverIp!,
if (status != null) 'status': status!,
if (userAgent != null) 'userAgent': userAgent!,
};
}
/// Network Connectivity Center is a hub-and-spoke abstraction for network
/// connectivity management in Google Cloud.
///
/// It reduces operational complexity through a simple, centralized connectivity
/// management model. Following is the resource message of a hub.
class Hub {
/// Time when the Hub was created.
core.String? createTime;
/// Short description of the hub resource.
core.String? description;
/// User-defined labels.
core.Map<core.String, core.String>? labels;
/// The name of a Hub resource.
///
/// Immutable.
core.String? name;
/// A list of the URIs of all attached spokes
///
/// Output only.
core.List<core.String>? spokes;
/// The current lifecycle state of this Hub.
///
/// Output only.
/// Possible string values are:
/// - "STATE_UNSPECIFIED" : No state information available
/// - "CREATING" : The resource's create operation is in progress
/// - "ACTIVE" : The resource is active
/// - "DELETING" : The resource's Delete operation is in progress
core.String? state;
/// Google-generated UUID for this resource.
///
/// This is unique across all Hub resources. If a Hub resource is deleted and
/// another with the same name is created, it gets a different unique_id.
///
/// Output only.
core.String? uniqueId;
/// Time when the Hub was updated.
core.String? updateTime;
Hub();
Hub.fromJson(core.Map _json) {
if (_json.containsKey('createTime')) {
createTime = _json['createTime'] as core.String;
}
if (_json.containsKey('description')) {
description = _json['description'] as core.String;
}
if (_json.containsKey('labels')) {
labels =
(_json['labels'] as core.Map).cast<core.String, core.String>().map(
(key, item) => core.MapEntry(
key,
item as core.String,
),
);
}
if (_json.containsKey('name')) {
name = _json['name'] as core.String;
}
if (_json.containsKey('spokes')) {
spokes = (_json['spokes'] 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('uniqueId')) {
uniqueId = _json['uniqueId'] as core.String;
}
if (_json.containsKey('updateTime')) {
updateTime = _json['updateTime'] as core.String;
}
}
core.Map<core.String, core.Object?> toJson() => {
if (createTime != null) 'createTime': createTime!,
if (description != null) 'description': description!,
if (labels != null) 'labels': labels!,
if (name != null) 'name': name!,
if (spokes != null) 'spokes': spokes!,
if (state != null) 'state': state!,
if (uniqueId != null) 'uniqueId': uniqueId!,
if (updateTime != null) 'updateTime': updateTime!,
};
}
/// Describing buckets with constant width.
class LinearBuckets {
/// The number of finite buckets.
///
/// With the underflow and overflow buckets, the total number of buckets is
/// `num_finite_buckets` + 2. See comments on `bucket_options` for details.
core.int? numFiniteBuckets;
/// The i'th linear bucket covers the interval \[offset + (i-1) * width,
/// offset + i * width) where i ranges from 1 to num_finite_buckets,
/// inclusive.
core.double? offset;
/// The i'th linear bucket covers the interval \[offset + (i-1) * width,
/// offset + i * width) where i ranges from 1 to num_finite_buckets,
/// inclusive.
///
/// Must be strictly positive.
core.double? width;
LinearBuckets();
LinearBuckets.fromJson(core.Map _json) {
if (_json.containsKey('numFiniteBuckets')) {
numFiniteBuckets = _json['numFiniteBuckets'] as core.int;
}
if (_json.containsKey('offset')) {
offset = (_json['offset'] as core.num).toDouble();
}
if (_json.containsKey('width')) {
width = (_json['width'] as core.num).toDouble();
}
}
core.Map<core.String, core.Object?> toJson() => {
if (numFiniteBuckets != null) 'numFiniteBuckets': numFiniteBuckets!,
if (offset != null) 'offset': offset!,
if (width != null) 'width': width!,
};
}
/// Response for HubService.ListHubs method.
class ListHubsResponse {
/// Hubs to be returned.
core.List<Hub>? hubs;
/// The next pagination token in the List response.
///
/// It should be used as page_token for the following request. An empty value
/// means no more result.
core.String? nextPageToken;
/// Locations that could not be reached.
core.List<core.String>? unreachable;
ListHubsResponse();
ListHubsResponse.fromJson(core.Map _json) {
if (_json.containsKey('hubs')) {
hubs = (_json['hubs'] as core.List)
.map<Hub>((value) =>
Hub.fromJson(value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('nextPageToken')) {
nextPageToken = _json['nextPageToken'] as core.String;
}
if (_json.containsKey('unreachable')) {
unreachable = (_json['unreachable'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
}
core.Map<core.String, core.Object?> toJson() => {
if (hubs != null) 'hubs': hubs!.map((value) => value.toJson()).toList(),
if (nextPageToken != null) 'nextPageToken': nextPageToken!,
if (unreachable != null) 'unreachable': unreachable!,
};
}
/// The response message for Locations.ListLocations.
class ListLocationsResponse {
/// A list of locations that matches the specified filter in the request.
core.List<Location>? locations;
/// The standard List next-page token.
core.String? nextPageToken;
ListLocationsResponse();
ListLocationsResponse.fromJson(core.Map _json) {
if (_json.containsKey('locations')) {
locations = (_json['locations'] as core.List)
.map<Location>((value) =>
Location.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() => {
if (locations != null)
'locations': locations!.map((value) => value.toJson()).toList(),
if (nextPageToken != null) 'nextPageToken': nextPageToken!,
};
}
/// The response for HubService.ListSpokes.
class ListSpokesResponse {
/// The next pagination token in the List response.
///
/// It should be used as page_token for the following request. An empty value
/// means no more result.
core.String? nextPageToken;
/// Spokes to be returned.
core.List<Spoke>? spokes;
/// Locations that could not be reached.
core.List<core.String>? unreachable;
ListSpokesResponse();
ListSpokesResponse.fromJson(core.Map _json) {
if (_json.containsKey('nextPageToken')) {
nextPageToken = _json['nextPageToken'] as core.String;
}
if (_json.containsKey('spokes')) {
spokes = (_json['spokes'] as core.List)
.map<Spoke>((value) =>
Spoke.fromJson(value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('unreachable')) {
unreachable = (_json['unreachable'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
}
core.Map<core.String, core.Object?> toJson() => {
if (nextPageToken != null) 'nextPageToken': nextPageToken!,
if (spokes != null)
'spokes': spokes!.map((value) => value.toJson()).toList(),
if (unreachable != null) 'unreachable': unreachable!,
};
}
/// A resource that represents Google Cloud Platform location.
class Location {
/// The friendly name for this location, typically a nearby city name.
///
/// For example, "Tokyo".
core.String? displayName;
/// Cross-service attributes for the location.
///
/// For example {"cloud.googleapis.com/region": "us-east1"}
core.Map<core.String, core.String>? labels;
/// The canonical id for this location.
///
/// For example: `"us-east1"`.
core.String? locationId;
/// Service-specific metadata.
///
/// For example the available capacity at the given location.
///
/// 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;
/// Resource name for the location, which may vary between implementations.
///
/// For example: `"projects/example-project/locations/us-east1"`
core.String? name;
Location();
Location.fromJson(core.Map _json) {
if (_json.containsKey('displayName')) {
displayName = _json['displayName'] as core.String;
}
if (_json.containsKey('labels')) {
labels =
(_json['labels'] as core.Map).cast<core.String, core.String>().map(
(key, item) => core.MapEntry(
key,
item as core.String,
),
);
}
if (_json.containsKey('locationId')) {
locationId = _json['locationId'] as core.String;
}
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;
}
}
core.Map<core.String, core.Object?> toJson() => {
if (displayName != null) 'displayName': displayName!,
if (labels != null) 'labels': labels!,
if (locationId != null) 'locationId': locationId!,
if (metadata != null) 'metadata': metadata!,
if (name != null) 'name': name!,
};
}
/// An individual log entry.
class LogEntry {
/// Information about the HTTP request associated with this log entry, if
/// applicable.
///
/// Optional.
HttpRequest? httpRequest;
/// A unique ID for the log entry used for deduplication.
///
/// If omitted, the implementation will generate one based on operation_id.
core.String? insertId;
/// A set of user-defined (key, value) data that provides additional
/// information about the log entry.
core.Map<core.String, core.String>? labels;
/// The log to which this log entry belongs.
///
/// Examples: `"syslog"`, `"book_log"`.
///
/// Required.
core.String? name;
/// Information about an operation associated with the log entry, if
/// applicable.
///
/// Optional.
LogEntryOperation? operation;
/// The log entry payload, represented as a protocol buffer that is expressed
/// as a JSON object.
///
/// The only accepted type currently is AuditLog.
///
/// 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>? protoPayload;
/// The severity of the log entry.
///
/// The default value is `LogSeverity.DEFAULT`.
/// Possible string values are:
/// - "DEFAULT" : (0) The log entry has no assigned severity level.
/// - "DEBUG" : (100) Debug or trace information.
/// - "INFO" : (200) Routine information, such as ongoing status or
/// performance.
/// - "NOTICE" : (300) Normal but significant events, such as start up, shut
/// down, or a configuration change.
/// - "WARNING" : (400) Warning events might cause problems.
/// - "ERROR" : (500) Error events are likely to cause problems.
/// - "CRITICAL" : (600) Critical events cause more severe problems or
/// outages.
/// - "ALERT" : (700) A person must take an action immediately.
/// - "EMERGENCY" : (800) One or more systems are unusable.
core.String? severity;
/// Source code location information associated with the log entry, if any.
///
/// Optional.
LogEntrySourceLocation? sourceLocation;
/// The log entry payload, represented as a structure that is expressed as a
/// JSON object.
///
/// 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>? structPayload;
/// The log entry payload, represented as a Unicode string (UTF-8).
core.String? textPayload;
/// The time the event described by the log entry occurred.
///
/// If omitted, defaults to operation start time.
core.String? timestamp;
/// Resource name of the trace associated with the log entry, if any.
///
/// If this field contains a relative resource name, you can assume the name
/// is relative to `//tracing.googleapis.com`. Example:
/// `projects/my-projectid/traces/06796866738c859f2f19b7cfb3214824`
///
/// Optional.
core.String? trace;
LogEntry();
LogEntry.fromJson(core.Map _json) {
if (_json.containsKey('httpRequest')) {
httpRequest = HttpRequest.fromJson(
_json['httpRequest'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('insertId')) {
insertId = _json['insertId'] as core.String;
}
if (_json.containsKey('labels')) {
labels =
(_json['labels'] as core.Map).cast<core.String, core.String>().map(
(key, item) => core.MapEntry(
key,
item as core.String,
),
);
}
if (_json.containsKey('name')) {
name = _json['name'] as core.String;
}
if (_json.containsKey('operation')) {
operation = LogEntryOperation.fromJson(
_json['operation'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('protoPayload')) {
protoPayload = (_json['protoPayload'] as core.Map)
.cast<core.String, core.Object>()
.map(
(key, item) => core.MapEntry(
key,
item as core.Object,
),
);
}
if (_json.containsKey('severity')) {
severity = _json['severity'] as core.String;
}
if (_json.containsKey('sourceLocation')) {
sourceLocation = LogEntrySourceLocation.fromJson(
_json['sourceLocation'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('structPayload')) {
structPayload = (_json['structPayload'] as core.Map)
.cast<core.String, core.Object>()
.map(
(key, item) => core.MapEntry(
key,
item as core.Object,
),
);
}
if (_json.containsKey('textPayload')) {
textPayload = _json['textPayload'] as core.String;
}
if (_json.containsKey('timestamp')) {
timestamp = _json['timestamp'] as core.String;
}
if (_json.containsKey('trace')) {
trace = _json['trace'] as core.String;
}
}
core.Map<core.String, core.Object?> toJson() => {
if (httpRequest != null) 'httpRequest': httpRequest!.toJson(),
if (insertId != null) 'insertId': insertId!,
if (labels != null) 'labels': labels!,
if (name != null) 'name': name!,
if (operation != null) 'operation': operation!.toJson(),
if (protoPayload != null) 'protoPayload': protoPayload!,
if (severity != null) 'severity': severity!,
if (sourceLocation != null) 'sourceLocation': sourceLocation!.toJson(),
if (structPayload != null) 'structPayload': structPayload!,
if (textPayload != null) 'textPayload': textPayload!,
if (timestamp != null) 'timestamp': timestamp!,
if (trace != null) 'trace': trace!,
};
}
/// Additional information about a potentially long-running operation with which
/// a log entry is associated.
class LogEntryOperation {
/// Set this to True if this is the first log entry in the operation.
///
/// Optional.
core.bool? first;
/// An arbitrary operation identifier.
///
/// Log entries with the same identifier are assumed to be part of the same
/// operation.
///
/// Optional.
core.String? id;
/// Set this to True if this is the last log entry in the operation.
///
/// Optional.
core.bool? last;
/// An arbitrary producer identifier.
///
/// The combination of `id` and `producer` must be globally unique. Examples
/// for `producer`: `"MyDivision.MyBigCompany.com"`,
/// `"github.com/MyProject/MyApplication"`.
///
/// Optional.
core.String? producer;
LogEntryOperation();
LogEntryOperation.fromJson(core.Map _json) {
if (_json.containsKey('first')) {
first = _json['first'] as core.bool;
}
if (_json.containsKey('id')) {
id = _json['id'] as core.String;
}
if (_json.containsKey('last')) {
last = _json['last'] as core.bool;
}
if (_json.containsKey('producer')) {
producer = _json['producer'] as core.String;
}
}
core.Map<core.String, core.Object?> toJson() => {
if (first != null) 'first': first!,
if (id != null) 'id': id!,
if (last != null) 'last': last!,
if (producer != null) 'producer': producer!,
};
}
/// Additional information about the source code location that produced the log
/// entry.
class LogEntrySourceLocation {
/// Source file name.
///
/// Depending on the runtime environment, this might be a simple name or a
/// fully-qualified name.
///
/// Optional.
core.String? file;
/// Human-readable name of the function or method being invoked, with optional
/// context such as the class or package name.
///
/// This information may be used in contexts such as the logs viewer, where a
/// file and line number are less meaningful. The format can vary by language.
/// For example: `qual.if.ied.Class.method` (Java), `dir/package.func` (Go),
/// `function` (Python).
///
/// Optional.
core.String? function;
/// Line within the source file.
///
/// 1-based; 0 indicates no line number available.
///
/// Optional.
core.String? line;
LogEntrySourceLocation();
LogEntrySourceLocation.fromJson(core.Map _json) {
if (_json.containsKey('file')) {
file = _json['file'] as core.String;
}
if (_json.containsKey('function')) {
function = _json['function'] as core.String;
}
if (_json.containsKey('line')) {
line = _json['line'] as core.String;
}
}
core.Map<core.String, core.Object?> toJson() => {
if (file != null) 'file': file!,
if (function != null) 'function': function!,
if (line != null) 'line': line!,
};
}
/// Represents a single metric value.
class MetricValue {
/// A boolean value.
core.bool? boolValue;
/// A distribution value.
Distribution? distributionValue;
/// A double precision floating point value.
core.double? doubleValue;
/// The end of the time period over which this metric value's measurement
/// applies.
///
/// If not specified, google.api.servicecontrol.v1.Operation.end_time will be
/// used.
core.String? endTime;
/// A signed 64-bit integer value.
core.String? int64Value;
/// The labels describing the metric value.
///
/// See comments on google.api.servicecontrol.v1.Operation.labels for the
/// overriding relationship. Note that this map must not contain monitored
/// resource labels.
core.Map<core.String, core.String>? labels;
/// A money value.
Money? moneyValue;
/// The start of the time period over which this metric value's measurement
/// applies.
///
/// The time period has different semantics for different metric types
/// (cumulative, delta, and gauge). See the metric definition documentation in
/// the service configuration for details. If not specified,
/// google.api.servicecontrol.v1.Operation.start_time will be used.
core.String? startTime;
/// A text string value.
core.String? stringValue;
MetricValue();
MetricValue.fromJson(core.Map _json) {
if (_json.containsKey('boolValue')) {
boolValue = _json['boolValue'] as core.bool;
}
if (_json.containsKey('distributionValue')) {
distributionValue = Distribution.fromJson(
_json['distributionValue'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('doubleValue')) {
doubleValue = (_json['doubleValue'] as core.num).toDouble();
}
if (_json.containsKey('endTime')) {
endTime = _json['endTime'] as core.String;
}
if (_json.containsKey('int64Value')) {
int64Value = _json['int64Value'] as core.String;
}
if (_json.containsKey('labels')) {
labels =
(_json['labels'] as core.Map).cast<core.String, core.String>().map(
(key, item) => core.MapEntry(
key,
item as core.String,
),
);
}
if (_json.containsKey('moneyValue')) {
moneyValue = Money.fromJson(
_json['moneyValue'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('startTime')) {
startTime = _json['startTime'] as core.String;
}
if (_json.containsKey('stringValue')) {
stringValue = _json['stringValue'] as core.String;
}
}
core.Map<core.String, core.Object?> toJson() => {
if (boolValue != null) 'boolValue': boolValue!,
if (distributionValue != null)
'distributionValue': distributionValue!.toJson(),
if (doubleValue != null) 'doubleValue': doubleValue!,
if (endTime != null) 'endTime': endTime!,
if (int64Value != null) 'int64Value': int64Value!,
if (labels != null) 'labels': labels!,
if (moneyValue != null) 'moneyValue': moneyValue!.toJson(),
if (startTime != null) 'startTime': startTime!,
if (stringValue != null) 'stringValue': stringValue!,
};
}
/// Represents a set of metric values in the same metric.
///
/// Each metric value in the set should have a unique combination of start time,
/// end time, and label values.
class MetricValueSet {
/// The metric name defined in the service configuration.
core.String? metricName;
/// The values in this metric.
core.List<MetricValue>? metricValues;
MetricValueSet();
MetricValueSet.fromJson(core.Map _json) {
if (_json.containsKey('metricName')) {
metricName = _json['metricName'] as core.String;
}
if (_json.containsKey('metricValues')) {
metricValues = (_json['metricValues'] as core.List)
.map<MetricValue>((value) => MetricValue.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
}
core.Map<core.String, core.Object?> toJson() => {
if (metricName != null) 'metricName': metricName!,
if (metricValues != null)
'metricValues': metricValues!.map((value) => value.toJson()).toList(),
};
}
/// Represents an amount of money with its currency type.
class Money {
/// The three-letter currency code defined in ISO 4217.
core.String? currencyCode;
/// Number of nano (10^-9) units of the amount.
///
/// The value must be between -999,999,999 and +999,999,999 inclusive. If
/// `units` is positive, `nanos` must be positive or zero. If `units` is zero,
/// `nanos` can be positive, zero, or negative. If `units` is negative,
/// `nanos` must be negative or zero. For example $-1.75 is represented as
/// `units`=-1 and `nanos`=-750,000,000.
core.int? nanos;
/// The whole units of the amount.
///
/// For example if `currencyCode` is `"USD"`, then 1 unit is one US dollar.
core.String? units;
Money();
Money.fromJson(core.Map _json) {
if (_json.containsKey('currencyCode')) {
currencyCode = _json['currencyCode'] as core.String;
}
if (_json.containsKey('nanos')) {
nanos = _json['nanos'] as core.int;
}
if (_json.containsKey('units')) {
units = _json['units'] as core.String;
}
}
core.Map<core.String, core.Object?> toJson() => {
if (currencyCode != null) 'currencyCode': currencyCode!,
if (nanos != null) 'nanos': nanos!,
if (units != null) 'units': units!,
};
}
/// Represents information regarding an operation.
class Operation {
/// Identity of the consumer who is using the service.
///
/// This field should be filled in for the operations initiated by a consumer,
/// but not for service-initiated operations that are not related to a
/// specific consumer. - This can be in one of the following formats: -
/// project:PROJECT_ID, - project`_`number:PROJECT_NUMBER, -
/// projects/PROJECT_ID or PROJECT_NUMBER, - folders/FOLDER_NUMBER, -
/// organizations/ORGANIZATION_NUMBER, - api`_`key:API_KEY.
core.String? consumerId;
/// End time of the operation.
///
/// Required when the operation is used in ServiceController.Report, but
/// optional when the operation is used in ServiceController.Check.
core.String? endTime;
/// Unimplemented.
///
/// 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>>? extensions;
/// DO NOT USE.
///
/// This is an experimental field.
/// Possible string values are:
/// - "LOW" : Allows data caching, batching, and aggregation. It provides
/// higher performance with higher data loss risk.
/// - "HIGH" : Disables data aggregation to minimize data loss. It is for
/// operations that contains significant monetary value or audit trail. This
/// feature only applies to the client libraries.
/// - "DEBUG" : Deprecated. Do not use. Disables data aggregation and enables
/// additional validation logic. It should only be used during the onboarding
/// process. It is only available to Google internal services, and the service
/// must be approved by chemist-dev@google.com in order to use this level.
core.String? importance;
/// Labels describing the operation.
///
/// Only the following labels are allowed: - Labels describing monitored
/// resources as defined in the service configuration. - Default labels of
/// metric values. When specified, labels defined in the metric value override
/// these default. - The following labels defined by Google Cloud Platform: -
/// `cloud.googleapis.com/location` describing the location where the
/// operation happened, - `servicecontrol.googleapis.com/user_agent`
/// describing the user agent of the API request, -
/// `servicecontrol.googleapis.com/service_agent` describing the service used
/// to handle the API request (e.g. ESP), -
/// `servicecontrol.googleapis.com/platform` describing the platform where the
/// API is served, such as App Engine, Compute Engine, or Kubernetes Engine.
core.Map<core.String, core.String>? labels;
/// Represents information to be logged.
core.List<LogEntry>? logEntries;
/// Represents information about this operation.
///
/// Each MetricValueSet corresponds to a metric defined in the service
/// configuration. The data type used in the MetricValueSet must agree with
/// the data type specified in the metric definition. Within a single
/// operation, it is not allowed to have more than one MetricValue instances
/// that have the same metric names and identical label value combinations. If
/// a request has such duplicated MetricValue instances, the entire request is
/// rejected with an invalid argument error.
core.List<MetricValueSet>? metricValueSets;
/// Identity of the operation.
///
/// This must be unique within the scope of the service that generated the
/// operation. If the service calls Check() and Report() on the same
/// operation, the two calls should carry the same id. UUID version 4 is
/// recommended, though not required. In scenarios where an operation is
/// computed from existing information and an idempotent id is desirable for
/// deduplication purpose, UUID version 5 is recommended. See RFC 4122 for
/// details.
core.String? operationId;
/// Fully qualified name of the operation.
///
/// Reserved for future use.
core.String? operationName;
/// Represents the properties needed for quota check.
///
/// Applicable only if this operation is for a quota check request. If this is
/// not specified, no quota check will be performed.
QuotaProperties? quotaProperties;
/// The resources that are involved in the operation.
///
/// The maximum supported number of entries in this field is 100.
core.List<ResourceInfo>? resources;
/// Start time of the operation.
///
/// Required.
core.String? startTime;
/// A list of Cloud Trace spans.
///
/// The span names shall contain the id of the destination project which can
/// be either the produce or the consumer project.
///
/// Unimplemented.
core.List<TraceSpan>? traceSpans;
/// Private Preview.
///
/// This feature is only available for approved services. User defined labels
/// for the resource that this operation is associated with. Only a
/// combination of 1000 user labels per consumer project are allowed.
core.Map<core.String, core.String>? userLabels;
Operation();
Operation.fromJson(core.Map _json) {
if (_json.containsKey('consumerId')) {
consumerId = _json['consumerId'] as core.String;
}
if (_json.containsKey('endTime')) {
endTime = _json['endTime'] as core.String;
}
if (_json.containsKey('extensions')) {
extensions = (_json['extensions'] 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('importance')) {
importance = _json['importance'] as core.String;
}
if (_json.containsKey('labels')) {
labels =
(_json['labels'] as core.Map).cast<core.String, core.String>().map(
(key, item) => core.MapEntry(
key,
item as core.String,
),
);
}
if (_json.containsKey('logEntries')) {
logEntries = (_json['logEntries'] as core.List)
.map<LogEntry>((value) =>
LogEntry.fromJson(value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('metricValueSets')) {
metricValueSets = (_json['metricValueSets'] as core.List)
.map<MetricValueSet>((value) => MetricValueSet.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('operationId')) {
operationId = _json['operationId'] as core.String;
}
if (_json.containsKey('operationName')) {
operationName = _json['operationName'] as core.String;
}
if (_json.containsKey('quotaProperties')) {
quotaProperties = QuotaProperties.fromJson(
_json['quotaProperties'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('resources')) {
resources = (_json['resources'] as core.List)
.map<ResourceInfo>((value) => ResourceInfo.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('startTime')) {
startTime = _json['startTime'] as core.String;
}
if (_json.containsKey('traceSpans')) {
traceSpans = (_json['traceSpans'] as core.List)
.map<TraceSpan>((value) =>
TraceSpan.fromJson(value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('userLabels')) {
userLabels = (_json['userLabels'] 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() => {
if (consumerId != null) 'consumerId': consumerId!,
if (endTime != null) 'endTime': endTime!,
if (extensions != null) 'extensions': extensions!,
if (importance != null) 'importance': importance!,
if (labels != null) 'labels': labels!,
if (logEntries != null)
'logEntries': logEntries!.map((value) => value.toJson()).toList(),
if (metricValueSets != null)
'metricValueSets':
metricValueSets!.map((value) => value.toJson()).toList(),
if (operationId != null) 'operationId': operationId!,
if (operationName != null) 'operationName': operationName!,
if (quotaProperties != null)
'quotaProperties': quotaProperties!.toJson(),
if (resources != null)
'resources': resources!.map((value) => value.toJson()).toList(),
if (startTime != null) 'startTime': startTime!,
if (traceSpans != null)
'traceSpans': traceSpans!.map((value) => value.toJson()).toList(),
if (userLabels != null) 'userLabels': userLabels!,
};
}
/// Represents the metadata of the long-running operation.
class OperationMetadata {
/// API version used to start the operation.
///
/// Output only.
core.String? apiVersion;
/// The time the operation was created.
///
/// Output only.
core.String? createTime;
/// The time the operation finished running.
///
/// Output only.
core.String? endTime;
/// Identifies whether the user has requested cancellation of the operation.
///
/// Operations that have successfully been cancelled have Operation.error
/// value with a google.rpc.Status.code of 1, corresponding to
/// `Code.CANCELLED`.
///
/// Output only.
core.bool? requestedCancellation;
/// Human-readable status of the operation, if any.
///
/// Output only.
core.String? statusMessage;
/// Server-defined resource path for the target of the operation.
///
/// Output only.
core.String? target;
/// Name of the verb executed by the operation.
///
/// Output only.
core.String? verb;
OperationMetadata();
OperationMetadata.fromJson(core.Map _json) {
if (_json.containsKey('apiVersion')) {
apiVersion = _json['apiVersion'] as core.String;
}
if (_json.containsKey('createTime')) {
createTime = _json['createTime'] as core.String;
}
if (_json.containsKey('endTime')) {
endTime = _json['endTime'] as core.String;
}
if (_json.containsKey('requestedCancellation')) {
requestedCancellation = _json['requestedCancellation'] as core.bool;
}
if (_json.containsKey('statusMessage')) {
statusMessage = _json['statusMessage'] as core.String;
}
if (_json.containsKey('target')) {
target = _json['target'] as core.String;
}
if (_json.containsKey('verb')) {
verb = _json['verb'] as core.String;
}
}
core.Map<core.String, core.Object?> toJson() => {
if (apiVersion != null) 'apiVersion': apiVersion!,
if (createTime != null) 'createTime': createTime!,
if (endTime != null) 'endTime': endTime!,
if (requestedCancellation != null)
'requestedCancellation': requestedCancellation!,
if (statusMessage != null) 'statusMessage': statusMessage!,
if (target != null) 'target': target!,
if (verb != null) 'verb': verb!,
};
}
/// An Identity and Access Management (IAM) policy, which specifies access
/// controls for Google Cloud resources.
///
/// A `Policy` is a collection of `bindings`. A `binding` binds one or more
/// `members` to a single `role`. Members can be user accounts, service
/// accounts, Google groups, and domains (such as G Suite). A `role` is a named
/// list of permissions; each `role` can be an IAM predefined role or a
/// user-created custom role. For some types of Google Cloud resources, a
/// `binding` can also specify a `condition`, which is a logical expression that
/// allows access to a resource only if the expression evaluates to `true`. A
/// condition can add constraints based on attributes of the request, the
/// resource, or both. To learn which resources support conditions in their IAM
/// policies, see the
/// [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
/// **JSON example:** { "bindings": \[ { "role":
/// "roles/resourcemanager.organizationAdmin", "members": \[
/// "user:mike@example.com", "group:admins@example.com", "domain:google.com",
/// "serviceAccount:my-project-id@appspot.gserviceaccount.com" \] }, { "role":
/// "roles/resourcemanager.organizationViewer", "members": \[
/// "user:eve@example.com" \], "condition": { "title": "expirable access",
/// "description": "Does not grant access after Sep 2020", "expression":
/// "request.time < timestamp('2020-10-01T00:00:00.000Z')", } } \], "etag":
/// "BwWWja0YfJA=", "version": 3 } **YAML example:** bindings: - members: -
/// user:mike@example.com - group:admins@example.com - domain:google.com -
/// serviceAccount:my-project-id@appspot.gserviceaccount.com role:
/// roles/resourcemanager.organizationAdmin - members: - user:eve@example.com
/// role: roles/resourcemanager.organizationViewer condition: title: expirable
/// access description: Does not grant access after Sep 2020 expression:
/// request.time < timestamp('2020-10-01T00:00:00.000Z') - etag: BwWWja0YfJA= -
/// version: 3 For a description of IAM and its features, see the
/// [IAM documentation](https://cloud.google.com/iam/docs/).
class Policy {
/// Specifies cloud audit logging configuration for this policy.
core.List<AuditConfig>? auditConfigs;
/// Associates a list of `members` to a `role`.
///
/// Optionally, may specify a `condition` that determines how and when the
/// `bindings` are applied. Each of the `bindings` must contain at least one
/// member.
core.List<Binding>? bindings;
/// `etag` is used for optimistic concurrency control as a way to help prevent
/// simultaneous updates of a policy from overwriting each other.
///
/// It is strongly suggested that systems make use of the `etag` in the
/// read-modify-write cycle to perform policy updates in order to avoid race
/// conditions: An `etag` is returned in the response to `getIamPolicy`, and
/// systems are expected to put that etag in the request to `setIamPolicy` to
/// ensure that their change will be applied to the same version of the
/// policy. **Important:** If you use IAM Conditions, you must include the
/// `etag` field whenever you call `setIamPolicy`. If you omit this field,
/// then IAM allows you to overwrite a version `3` policy with a version `1`
/// policy, and all of the conditions in the version `3` policy are lost.
core.String? etag;
core.List<core.int> get etagAsBytes => convert.base64.decode(etag!);
set etagAsBytes(core.List<core.int> _bytes) {
etag =
convert.base64.encode(_bytes).replaceAll('/', '_').replaceAll('+', '-');
}
/// Specifies the format of the policy.
///
/// Valid values are `0`, `1`, and `3`. Requests that specify an invalid value
/// are rejected. Any operation that affects conditional role bindings must
/// specify version `3`. This requirement applies to the following operations:
/// * Getting a policy that includes a conditional role binding * Adding a
/// conditional role binding to a policy * Changing a conditional role binding
/// in a policy * Removing any role binding, with or without a condition, from
/// a policy that includes conditions **Important:** If you use IAM
/// Conditions, you must include the `etag` field whenever you call
/// `setIamPolicy`. If you omit this field, then IAM allows you to overwrite a
/// version `3` policy with a version `1` policy, and all of the conditions in
/// the version `3` policy are lost. If a policy does not include any
/// conditions, operations on that policy may specify any valid version or
/// leave the field unset. To learn which resources support conditions in
/// their IAM policies, see the
/// [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
core.int? version;
Policy();
Policy.fromJson(core.Map _json) {
if (_json.containsKey('auditConfigs')) {
auditConfigs = (_json['auditConfigs'] as core.List)
.map<AuditConfig>((value) => AuditConfig.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('bindings')) {
bindings = (_json['bindings'] as core.List)
.map<Binding>((value) =>
Binding.fromJson(value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('etag')) {
etag = _json['etag'] as core.String;
}
if (_json.containsKey('version')) {
version = _json['version'] as core.int;
}
}
core.Map<core.String, core.Object?> toJson() => {
if (auditConfigs != null)
'auditConfigs': auditConfigs!.map((value) => value.toJson()).toList(),
if (bindings != null)
'bindings': bindings!.map((value) => value.toJson()).toList(),
if (etag != null) 'etag': etag!,
if (version != null) 'version': version!,
};
}
/// Represents the properties needed for quota operations.
class QuotaProperties {
/// Quota mode for this operation.
/// Possible string values are:
/// - "ACQUIRE" : Decreases available quota by the cost specified for the
/// operation. If cost is higher than available quota, operation fails and
/// returns error.
/// - "ACQUIRE_BEST_EFFORT" : Decreases available quota by the cost specified
/// for the operation. If cost is higher than available quota, operation does
/// not fail and available quota goes down to zero but it returns error.
/// - "CHECK" : Does not change any available quota. Only checks if there is
/// enough quota. No lock is placed on the checked tokens neither.
/// - "RELEASE" : Increases available quota by the operation cost specified
/// for the operation.
core.String? quotaMode;
QuotaProperties();
QuotaProperties.fromJson(core.Map _json) {
if (_json.containsKey('quotaMode')) {
quotaMode = _json['quotaMode'] as core.String;
}
}
core.Map<core.String, core.Object?> toJson() => {
if (quotaMode != null) 'quotaMode': quotaMode!,
};
}
/// Request message for the Report method.
class ReportRequest {
/// Operations to be reported.
///
/// Typically the service should report one operation per request. Putting
/// multiple operations into a single request is allowed, but should be used
/// only when multiple operations are natually available at the time of the
/// report. There is no limit on the number of operations in the same
/// ReportRequest, however the ReportRequest size should be no larger than
/// 1MB. See ReportResponse.report_errors for partial failure behavior.
core.List<Operation>? operations;
/// Specifies which version of service config should be used to process the
/// request.
///
/// If unspecified or no matching version can be found, the latest one will be
/// used.
core.String? serviceConfigId;
/// The service name as specified in its service configuration.
///
/// For example, `"pubsub.googleapis.com"`. See
/// [google.api.Service](https://cloud.google.com/service-management/reference/rpc/google.api#google.api.Service)
/// for the definition of a service name.
core.String? serviceName;
ReportRequest();
ReportRequest.fromJson(core.Map _json) {
if (_json.containsKey('operations')) {
operations = (_json['operations'] as core.List)
.map<Operation>((value) =>
Operation.fromJson(value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('serviceConfigId')) {
serviceConfigId = _json['serviceConfigId'] as core.String;
}
if (_json.containsKey('serviceName')) {
serviceName = _json['serviceName'] as core.String;
}
}
core.Map<core.String, core.Object?> toJson() => {
if (operations != null)
'operations': operations!.map((value) => value.toJson()).toList(),
if (serviceConfigId != null) 'serviceConfigId': serviceConfigId!,
if (serviceName != null) 'serviceName': serviceName!,
};
}
/// Describes a resource associated with this operation.
class ResourceInfo {
/// The identifier of the parent of this resource instance.
///
/// Must be in one of the following formats: - `projects/` - `folders/` -
/// `organizations/`
core.String? resourceContainer;
/// The location of the resource.
///
/// If not empty, the resource will be checked against location policy. The
/// value must be a valid zone, region or multiregion. For example:
/// "europe-west4" or "northamerica-northeast1-a"
core.String? resourceLocation;
/// Name of the resource.
///
/// This is used for auditing purposes.
core.String? resourceName;
ResourceInfo();
ResourceInfo.fromJson(core.Map _json) {
if (_json.containsKey('resourceContainer')) {
resourceContainer = _json['resourceContainer'] as core.String;
}
if (_json.containsKey('resourceLocation')) {
resourceLocation = _json['resourceLocation'] as core.String;
}
if (_json.containsKey('resourceName')) {
resourceName = _json['resourceName'] as core.String;
}
}
core.Map<core.String, core.Object?> toJson() => {
if (resourceContainer != null) 'resourceContainer': resourceContainer!,
if (resourceLocation != null) 'resourceLocation': resourceLocation!,
if (resourceName != null) 'resourceName': resourceName!,
};
}
/// RouterAppliance represents a Router appliance which is specified by a VM URI
/// and a NIC address.
class RouterApplianceInstance {
/// The IP address of the network interface to use for peering.
core.String? ipAddress;
core.String? networkInterface;
/// The URI of the virtual machine resource
core.String? virtualMachine;
RouterApplianceInstance();
RouterApplianceInstance.fromJson(core.Map _json) {
if (_json.containsKey('ipAddress')) {
ipAddress = _json['ipAddress'] as core.String;
}
if (_json.containsKey('networkInterface')) {
networkInterface = _json['networkInterface'] as core.String;
}
if (_json.containsKey('virtualMachine')) {
virtualMachine = _json['virtualMachine'] as core.String;
}
}
core.Map<core.String, core.Object?> toJson() => {
if (ipAddress != null) 'ipAddress': ipAddress!,
if (networkInterface != null) 'networkInterface': networkInterface!,
if (virtualMachine != null) 'virtualMachine': virtualMachine!,
};
}
/// Request message for `SetIamPolicy` method.
class SetIamPolicyRequest {
/// REQUIRED: The complete policy to be applied to the `resource`.
///
/// The size of the policy is limited to a few 10s of KB. An empty policy is a
/// valid policy but certain Cloud Platform services (such as Projects) might
/// reject them.
Policy? policy;
/// OPTIONAL: A FieldMask specifying which fields of the policy to modify.
///
/// Only the fields in the mask will be modified. If no mask is provided, the
/// following default mask is used: `paths: "bindings, etag"`
core.String? updateMask;
SetIamPolicyRequest();
SetIamPolicyRequest.fromJson(core.Map _json) {
if (_json.containsKey('policy')) {
policy = Policy.fromJson(
_json['policy'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('updateMask')) {
updateMask = _json['updateMask'] as core.String;
}
}
core.Map<core.String, core.Object?> toJson() => {
if (policy != null) 'policy': policy!.toJson(),
if (updateMask != null) 'updateMask': updateMask!,
};
}
/// A Spoke is an abstraction of a network attachment being attached to a Hub.
///
/// A Spoke can be underlying a VPN tunnel, a VLAN (interconnect) attachment, a
/// Router appliance, etc.
class Spoke {
/// The time when the Spoke was created.
core.String? createTime;
/// Short description of the spoke resource
core.String? description;
/// The resource URL of the hub resource that the spoke is attached to
core.String? hub;
/// User-defined labels.
core.Map<core.String, core.String>? labels;
/// The URIs of linked interconnect attachment resources
core.List<core.String>? linkedInterconnectAttachments;
/// The URIs of linked Router appliance resources
core.List<RouterApplianceInstance>? linkedRouterApplianceInstances;
/// The URIs of linked VPN tunnel resources
core.List<core.String>? linkedVpnTunnels;
/// The name of a Spoke resource.
///
/// Immutable.
core.String? name;
/// The current lifecycle state of this Hub.
///
/// Output only.
/// Possible string values are:
/// - "STATE_UNSPECIFIED" : No state information available
/// - "CREATING" : The resource's create operation is in progress
/// - "ACTIVE" : The resource is active
/// - "DELETING" : The resource's Delete operation is in progress
core.String? state;
/// Google-generated UUID for this resource.
///
/// This is unique across all Spoke resources. If a Spoke resource is deleted
/// and another with the same name is created, it gets a different unique_id.
///
/// Output only.
core.String? uniqueId;
/// The time when the Spoke was updated.
core.String? updateTime;
Spoke();
Spoke.fromJson(core.Map _json) {
if (_json.containsKey('createTime')) {
createTime = _json['createTime'] as core.String;
}
if (_json.containsKey('description')) {
description = _json['description'] as core.String;
}
if (_json.containsKey('hub')) {
hub = _json['hub'] as core.String;
}
if (_json.containsKey('labels')) {
labels =
(_json['labels'] as core.Map).cast<core.String, core.String>().map(
(key, item) => core.MapEntry(
key,
item as core.String,
),
);
}
if (_json.containsKey('linkedInterconnectAttachments')) {
linkedInterconnectAttachments =
(_json['linkedInterconnectAttachments'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
if (_json.containsKey('linkedRouterApplianceInstances')) {
linkedRouterApplianceInstances =
(_json['linkedRouterApplianceInstances'] as core.List)
.map<RouterApplianceInstance>((value) =>
RouterApplianceInstance.fromJson(
value as core.Map<core.String, core.dynamic>))
.toList();
}
if (_json.containsKey('linkedVpnTunnels')) {
linkedVpnTunnels = (_json['linkedVpnTunnels'] 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('state')) {
state = _json['state'] as core.String;
}
if (_json.containsKey('uniqueId')) {
uniqueId = _json['uniqueId'] as core.String;
}
if (_json.containsKey('updateTime')) {
updateTime = _json['updateTime'] as core.String;
}
}
core.Map<core.String, core.Object?> toJson() => {
if (createTime != null) 'createTime': createTime!,
if (description != null) 'description': description!,
if (hub != null) 'hub': hub!,
if (labels != null) 'labels': labels!,
if (linkedInterconnectAttachments != null)
'linkedInterconnectAttachments': linkedInterconnectAttachments!,
if (linkedRouterApplianceInstances != null)
'linkedRouterApplianceInstances': linkedRouterApplianceInstances!
.map((value) => value.toJson())
.toList(),
if (linkedVpnTunnels != null) 'linkedVpnTunnels': linkedVpnTunnels!,
if (name != null) 'name': name!,
if (state != null) 'state': state!,
if (uniqueId != null) 'uniqueId': uniqueId!,
if (updateTime != null) 'updateTime': updateTime!,
};
}
/// Request message for `TestIamPermissions` method.
class TestIamPermissionsRequest {
/// The set of permissions to check for the `resource`.
///
/// Permissions with wildcards (such as '*' or 'storage.*') are not allowed.
/// For more information see
/// [IAM Overview](https://cloud.google.com/iam/docs/overview#permissions).
core.List<core.String>? permissions;
TestIamPermissionsRequest();
TestIamPermissionsRequest.fromJson(core.Map _json) {
if (_json.containsKey('permissions')) {
permissions = (_json['permissions'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
}
core.Map<core.String, core.Object?> toJson() => {
if (permissions != null) 'permissions': permissions!,
};
}
/// Response message for `TestIamPermissions` method.
class TestIamPermissionsResponse {
/// A subset of `TestPermissionsRequest.permissions` that the caller is
/// allowed.
core.List<core.String>? permissions;
TestIamPermissionsResponse();
TestIamPermissionsResponse.fromJson(core.Map _json) {
if (_json.containsKey('permissions')) {
permissions = (_json['permissions'] as core.List)
.map<core.String>((value) => value as core.String)
.toList();
}
}
core.Map<core.String, core.Object?> toJson() => {
if (permissions != null) 'permissions': permissions!,
};
}
/// A span represents a single operation within a trace.
///
/// Spans can be nested to form a trace tree. Often, a trace contains a root
/// span that describes the end-to-end latency, and one or more subspans for its
/// sub-operations. A trace can also contain multiple root spans, or none at
/// all. Spans do not need to be contiguous—there may be gaps or overlaps
/// between spans in a trace.
class TraceSpan {
/// A set of attributes on the span.
///
/// You can have up to 32 attributes per span.
Attributes? attributes;
/// An optional number of child spans that were generated while this span was
/// active.
///
/// If set, allows implementation to detect missing child spans.
core.int? childSpanCount;
/// A description of the span's operation (up to 128 bytes).
///
/// Stackdriver Trace displays the description in the Google Cloud Platform
/// Console. For example, the display name can be a qualified method name or a
/// file name and a line number where the operation is called. A best practice
/// is to use the same display name within an application and at the same call
/// point. This makes it easier to correlate spans in different traces.
TruncatableString? displayName;
/// The end time of the span.
///
/// On the client side, this is the time kept by the local machine where the
/// span execution ends. On the server side, this is the time when the server
/// application handler stops running.
core.String? endTime;
/// The resource name of the span in the following format:
/// projects/\[PROJECT_ID\]/traces/\[TRACE_ID\]/spans/SPAN_ID is a unique
/// identifier for a trace within a project; it is a 32-character hexadecimal
/// encoding of a 16-byte array.
///
/// \[SPAN_ID\] is a unique identifier for a span within a trace; it is a
/// 16-character hexadecimal encoding of an 8-byte array.
core.String? name;
/// The \[SPAN_ID\] of this span's parent span.
///
/// If this is a root span, then this field must be empty.
core.String? parentSpanId;
/// (Optional) Set this parameter to indicate whether this span is in the same
/// process as its parent.
///
/// If you do not set this parameter, Stackdriver Trace is unable to take
/// advantage of this helpful information.
core.bool? sameProcessAsParentSpan;
/// The \[SPAN_ID\] portion of the span's resource name.
core.String? spanId;
/// Distinguishes between spans generated in a particular context.
///
/// For example, two spans with the same name may be distinguished using
/// `CLIENT` (caller) and `SERVER` (callee) to identify an RPC call.
/// Possible string values are:
/// - "SPAN_KIND_UNSPECIFIED" : Unspecified. Do NOT use as default.
/// Implementations MAY assume SpanKind.INTERNAL to be default.
/// - "INTERNAL" : Indicates that the span is used internally. Default value.
/// - "SERVER" : Indicates that the span covers server-side handling of an RPC
/// or other remote network request.
/// - "CLIENT" : Indicates that the span covers the client-side wrapper around
/// an RPC or other remote request.
/// - "PRODUCER" : Indicates that the span describes producer sending a
/// message to a broker. Unlike client and server, there is no direct critical
/// path latency relationship between producer and consumer spans (e.g.
/// publishing a message to a pubsub service).
/// - "CONSUMER" : Indicates that the span describes consumer receiving a
/// message from a broker. Unlike client and server, there is no direct
/// critical path latency relationship between producer and consumer spans
/// (e.g. receiving a message from a pubsub service subscription).
core.String? spanKind;
/// The start time of the span.
///
/// On the client side, this is the time kept by the local machine where the
/// span execution starts. On the server side, this is the time when the
/// server's application handler starts running.
core.String? startTime;
/// An optional final status for this span.
GoogleRpcStatus? status;
TraceSpan();
TraceSpan.fromJson(core.Map _json) {
if (_json.containsKey('attributes')) {
attributes = Attributes.fromJson(
_json['attributes'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('childSpanCount')) {
childSpanCount = _json['childSpanCount'] as core.int;
}
if (_json.containsKey('displayName')) {
displayName = TruncatableString.fromJson(
_json['displayName'] as core.Map<core.String, core.dynamic>);
}
if (_json.containsKey('endTime')) {
endTime = _json['endTime'] as core.String;
}
if (_json.containsKey('name')) {
name = _json['name'] as core.String;
}
if (_json.containsKey('parentSpanId')) {
parentSpanId = _json['parentSpanId'] as core.String;
}
if (_json.containsKey('sameProcessAsParentSpan')) {
sameProcessAsParentSpan = _json['sameProcessAsParentSpan'] as core.bool;
}
if (_json.containsKey('spanId')) {
spanId = _json['spanId'] as core.String;
}
if (_json.containsKey('spanKind')) {
spanKind = _json['spanKind'] as core.String;
}
if (_json.containsKey('startTime')) {
startTime = _json['startTime'] as core.String;
}
if (_json.containsKey('status')) {
status = GoogleRpcStatus.fromJson(
_json['status'] as core.Map<core.String, core.dynamic>);
}
}
core.Map<core.String, core.Object?> toJson() => {
if (attributes != null) 'attributes': attributes!.toJson(),
if (childSpanCount != null) 'childSpanCount': childSpanCount!,
if (displayName != null) 'displayName': displayName!.toJson(),
if (endTime != null) 'endTime': endTime!,
if (name != null) 'name': name!,
if (parentSpanId != null) 'parentSpanId': parentSpanId!,
if (sameProcessAsParentSpan != null)
'sameProcessAsParentSpan': sameProcessAsParentSpan!,
if (spanId != null) 'spanId': spanId!,
if (spanKind != null) 'spanKind': spanKind!,
if (startTime != null) 'startTime': startTime!,
if (status != null) 'status': status!.toJson(),
};
}
/// Represents a string that might be shortened to a specified length.
class TruncatableString {
/// The number of bytes removed from the original string.
///
/// If this value is 0, then the string was not shortened.
core.int? truncatedByteCount;
/// The shortened string.
///
/// For example, if the original string is 500 bytes long and the limit of the
/// string is 128 bytes, then `value` contains the first 128 bytes of the
/// 500-byte string. Truncation always happens on a UTF8 character boundary.
/// If there are multi-byte characters in the string, then the length of the
/// shortened string might be less than the size limit.
core.String? value;
TruncatableString();
TruncatableString.fromJson(core.Map _json) {
if (_json.containsKey('truncatedByteCount')) {
truncatedByteCount = _json['truncatedByteCount'] as core.int;
}
if (_json.containsKey('value')) {
value = _json['value'] as core.String;
}
}
core.Map<core.String, core.Object?> toJson() => {
if (truncatedByteCount != null)
'truncatedByteCount': truncatedByteCount!,
if (value != null) 'value': value!,
};
}