| // Copyright 2020 Google LLC. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // Code generated file. DO NOT EDIT. |
| |
| // Package servicemanagement provides access to the Service Management API. |
| // |
| // For product documentation, see: https://cloud.google.com/service-management/ |
| // |
| // Creating a client |
| // |
| // Usage example: |
| // |
| // import "google.golang.org/api/servicemanagement/v1" |
| // ... |
| // ctx := context.Background() |
| // servicemanagementService, err := servicemanagement.NewService(ctx) |
| // |
| // In this example, Google Application Default Credentials are used for authentication. |
| // |
| // For information on how to create and obtain Application Default Credentials, see https://developers.google.com/identity/protocols/application-default-credentials. |
| // |
| // Other authentication options |
| // |
| // By default, all available scopes (see "Constants") are used to authenticate. To restrict scopes, use option.WithScopes: |
| // |
| // servicemanagementService, err := servicemanagement.NewService(ctx, option.WithScopes(servicemanagement.ServiceManagementReadonlyScope)) |
| // |
| // To use an API key for authentication (note: some APIs do not support API keys), use option.WithAPIKey: |
| // |
| // servicemanagementService, err := servicemanagement.NewService(ctx, option.WithAPIKey("AIza...")) |
| // |
| // To use an OAuth token (e.g., a user token obtained via a three-legged OAuth flow), use option.WithTokenSource: |
| // |
| // config := &oauth2.Config{...} |
| // // ... |
| // token, err := config.Exchange(ctx, ...) |
| // servicemanagementService, err := servicemanagement.NewService(ctx, option.WithTokenSource(config.TokenSource(ctx, token))) |
| // |
| // See https://godoc.org/google.golang.org/api/option/ for details on options. |
| package servicemanagement // import "google.golang.org/api/servicemanagement/v1" |
| |
| import ( |
| "bytes" |
| "context" |
| "encoding/json" |
| "errors" |
| "fmt" |
| "io" |
| "net/http" |
| "net/url" |
| "strconv" |
| "strings" |
| |
| googleapi "google.golang.org/api/googleapi" |
| gensupport "google.golang.org/api/internal/gensupport" |
| option "google.golang.org/api/option" |
| internaloption "google.golang.org/api/option/internaloption" |
| htransport "google.golang.org/api/transport/http" |
| ) |
| |
| // Always reference these packages, just in case the auto-generated code |
| // below doesn't. |
| var _ = bytes.NewBuffer |
| var _ = strconv.Itoa |
| var _ = fmt.Sprintf |
| var _ = json.NewDecoder |
| var _ = io.Copy |
| var _ = url.Parse |
| var _ = gensupport.MarshalJSON |
| var _ = googleapi.Version |
| var _ = errors.New |
| var _ = strings.Replace |
| var _ = context.Canceled |
| var _ = internaloption.WithDefaultEndpoint |
| |
| const apiId = "servicemanagement:v1" |
| const apiName = "servicemanagement" |
| const apiVersion = "v1" |
| const basePath = "https://servicemanagement.googleapis.com/" |
| const mtlsBasePath = "https://servicemanagement.mtls.googleapis.com/" |
| |
| // OAuth2 scopes used by this API. |
| const ( |
| // View and manage your data across Google Cloud Platform services |
| CloudPlatformScope = "https://www.googleapis.com/auth/cloud-platform" |
| |
| // View your data across Google Cloud Platform services |
| CloudPlatformReadOnlyScope = "https://www.googleapis.com/auth/cloud-platform.read-only" |
| |
| // Manage your Google API service configuration |
| ServiceManagementScope = "https://www.googleapis.com/auth/service.management" |
| |
| // View your Google API service configuration |
| ServiceManagementReadonlyScope = "https://www.googleapis.com/auth/service.management.readonly" |
| ) |
| |
| // NewService creates a new APIService. |
| func NewService(ctx context.Context, opts ...option.ClientOption) (*APIService, error) { |
| scopesOption := option.WithScopes( |
| "https://www.googleapis.com/auth/cloud-platform", |
| "https://www.googleapis.com/auth/cloud-platform.read-only", |
| "https://www.googleapis.com/auth/service.management", |
| "https://www.googleapis.com/auth/service.management.readonly", |
| ) |
| // NOTE: prepend, so we don't override user-specified scopes. |
| opts = append([]option.ClientOption{scopesOption}, opts...) |
| opts = append(opts, internaloption.WithDefaultEndpoint(basePath)) |
| opts = append(opts, internaloption.WithDefaultMTLSEndpoint(mtlsBasePath)) |
| client, endpoint, err := htransport.NewClient(ctx, opts...) |
| if err != nil { |
| return nil, err |
| } |
| s, err := New(client) |
| if err != nil { |
| return nil, err |
| } |
| if endpoint != "" { |
| s.BasePath = endpoint |
| } |
| return s, nil |
| } |
| |
| // New creates a new APIService. It uses the provided http.Client for requests. |
| // |
| // Deprecated: please use NewService instead. |
| // To provide a custom HTTP client, use option.WithHTTPClient. |
| // If you are using google.golang.org/api/googleapis/transport.APIKey, use option.WithAPIKey with NewService instead. |
| func New(client *http.Client) (*APIService, error) { |
| if client == nil { |
| return nil, errors.New("client is nil") |
| } |
| s := &APIService{client: client, BasePath: basePath} |
| s.Operations = NewOperationsService(s) |
| s.Services = NewServicesService(s) |
| return s, nil |
| } |
| |
| type APIService struct { |
| client *http.Client |
| BasePath string // API endpoint base URL |
| UserAgent string // optional additional User-Agent fragment |
| |
| Operations *OperationsService |
| |
| Services *ServicesService |
| } |
| |
| func (s *APIService) userAgent() string { |
| if s.UserAgent == "" { |
| return googleapi.UserAgent |
| } |
| return googleapi.UserAgent + " " + s.UserAgent |
| } |
| |
| func NewOperationsService(s *APIService) *OperationsService { |
| rs := &OperationsService{s: s} |
| return rs |
| } |
| |
| type OperationsService struct { |
| s *APIService |
| } |
| |
| func NewServicesService(s *APIService) *ServicesService { |
| rs := &ServicesService{s: s} |
| rs.Configs = NewServicesConfigsService(s) |
| rs.Consumers = NewServicesConsumersService(s) |
| rs.Rollouts = NewServicesRolloutsService(s) |
| return rs |
| } |
| |
| type ServicesService struct { |
| s *APIService |
| |
| Configs *ServicesConfigsService |
| |
| Consumers *ServicesConsumersService |
| |
| Rollouts *ServicesRolloutsService |
| } |
| |
| func NewServicesConfigsService(s *APIService) *ServicesConfigsService { |
| rs := &ServicesConfigsService{s: s} |
| return rs |
| } |
| |
| type ServicesConfigsService struct { |
| s *APIService |
| } |
| |
| func NewServicesConsumersService(s *APIService) *ServicesConsumersService { |
| rs := &ServicesConsumersService{s: s} |
| return rs |
| } |
| |
| type ServicesConsumersService struct { |
| s *APIService |
| } |
| |
| func NewServicesRolloutsService(s *APIService) *ServicesRolloutsService { |
| rs := &ServicesRolloutsService{s: s} |
| return rs |
| } |
| |
| type ServicesRolloutsService struct { |
| s *APIService |
| } |
| |
| // Advice: Generated advice about this change, used for providing more |
| // information about how a change will affect the existing service. |
| type Advice struct { |
| // Description: Useful description for why this advice was applied and |
| // what actions should be taken to mitigate any implied risks. |
| Description string `json:"description,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Description") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Description") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Advice) MarshalJSON() ([]byte, error) { |
| type NoMethod Advice |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Api: Api is a light-weight descriptor for an API Interface. |
| // Interfaces are also described as "protocol buffer services" in some |
| // contexts, such as by the "service" keyword in a .proto file, but they |
| // are different from API Services, which represent a concrete |
| // implementation of an interface as opposed to simply a description of |
| // methods and bindings. They are also sometimes simply referred to as |
| // "APIs" in other contexts, such as the name of this message itself. |
| // See https://cloud.google.com/apis/design/glossary for detailed |
| // terminology. |
| type Api struct { |
| // Methods: The methods of this interface, in unspecified order. |
| Methods []*Method `json:"methods,omitempty"` |
| |
| // Mixins: Included interfaces. See Mixin. |
| Mixins []*Mixin `json:"mixins,omitempty"` |
| |
| // Name: The fully qualified name of this interface, including package |
| // name followed by the interface's simple name. |
| Name string `json:"name,omitempty"` |
| |
| // Options: Any metadata attached to the interface. |
| Options []*Option `json:"options,omitempty"` |
| |
| // SourceContext: Source context for the protocol buffer service |
| // represented by this message. |
| SourceContext *SourceContext `json:"sourceContext,omitempty"` |
| |
| // Syntax: The source syntax of the service. |
| // |
| // Possible values: |
| // "SYNTAX_PROTO2" - Syntax `proto2`. |
| // "SYNTAX_PROTO3" - Syntax `proto3`. |
| Syntax string `json:"syntax,omitempty"` |
| |
| // Version: A version string for this interface. If specified, must have |
| // the form `major-version.minor-version`, as in `1.10`. If the minor |
| // version is omitted, it defaults to zero. If the entire version field |
| // is empty, the major version is derived from the package name, as |
| // outlined below. If the field is not empty, the version in the package |
| // name will be verified to be consistent with what is provided here. |
| // The versioning schema uses [semantic versioning](http://semver.org) |
| // where the major version number indicates a breaking change and the |
| // minor version an additive, non-breaking change. Both version numbers |
| // are signals to users what to expect from different versions, and |
| // should be carefully chosen based on the product plan. The major |
| // version is also reflected in the package name of the interface, which |
| // must end in `v`, as in `google.feature.v1`. For major versions 0 and |
| // 1, the suffix can be omitted. Zero major versions must only be used |
| // for experimental, non-GA interfaces. |
| Version string `json:"version,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Methods") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Methods") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Api) MarshalJSON() ([]byte, error) { |
| type NoMethod Api |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // AuditConfig: 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. |
| type AuditConfig struct { |
| // AuditLogConfigs: The configuration for logging of each type of |
| // permission. |
| AuditLogConfigs []*AuditLogConfig `json:"auditLogConfigs,omitempty"` |
| |
| // Service: 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. |
| Service string `json:"service,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "AuditLogConfigs") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "AuditLogConfigs") to |
| // include in API requests with the JSON null value. By default, fields |
| // with empty values are omitted from API requests. However, any field |
| // with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *AuditConfig) MarshalJSON() ([]byte, error) { |
| type NoMethod AuditConfig |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // AuditLogConfig: 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. |
| type AuditLogConfig struct { |
| // ExemptedMembers: Specifies the identities that do not cause logging |
| // for this type of permission. Follows the same format of |
| // Binding.members. |
| ExemptedMembers []string `json:"exemptedMembers,omitempty"` |
| |
| // LogType: The log type that this config enables. |
| // |
| // Possible values: |
| // "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 |
| LogType string `json:"logType,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "ExemptedMembers") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "ExemptedMembers") to |
| // include in API requests with the JSON null value. By default, fields |
| // with empty values are omitted from API requests. However, any field |
| // with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *AuditLogConfig) MarshalJSON() ([]byte, error) { |
| type NoMethod AuditLogConfig |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // AuthProvider: Configuration for an authentication provider, including |
| // support for [JSON Web Token |
| // (JWT)](https://tools.ietf.org/html/draft-ietf-oauth-json-web-token-32) |
| // . |
| type AuthProvider struct { |
| // Audiences: The list of JWT |
| // [audiences](https://tools.ietf.org/html/draft-ietf-oauth-json-web-toke |
| // n-32#section-4.1.3). that are allowed to access. A JWT containing any |
| // of these audiences will be accepted. When this setting is absent, |
| // JWTs with audiences: - |
| // "https://[service.name]/[google.protobuf.Api.name]" - |
| // "https://[service.name]/" will be accepted. For example, if no |
| // audiences are in the setting, LibraryService API will accept JWTs |
| // with the following audiences: - |
| // https://library-example.googleapis.com/google.example.library.v1.LibraryService - https://library-example.googleapis.com/ Example: audiences: bookstore_android.apps.googleusercontent.com, |
| // bookstore_web.apps.googleusercontent.com |
| Audiences string `json:"audiences,omitempty"` |
| |
| // AuthorizationUrl: Redirect URL if JWT token is required but not |
| // present or is expired. Implement authorizationUrl of |
| // securityDefinitions in OpenAPI spec. |
| AuthorizationUrl string `json:"authorizationUrl,omitempty"` |
| |
| // Id: The unique identifier of the auth provider. It will be referred |
| // to by `AuthRequirement.provider_id`. Example: "bookstore_auth". |
| Id string `json:"id,omitempty"` |
| |
| // Issuer: Identifies the principal that issued the JWT. See |
| // https://tools.ietf.org/html/draft-ietf-oauth-json-web-token-32#section-4.1.1 Usually a URL or an email address. Example: https://securetoken.google.com Example: |
| // 1234567-compute@developer.gserviceaccount.com |
| Issuer string `json:"issuer,omitempty"` |
| |
| // JwksUri: URL of the provider's public key set to validate signature |
| // of the JWT. See [OpenID |
| // Discovery](https://openid.net/specs/openid-connect-discovery-1_0.html# |
| // ProviderMetadata). Optional if the key set document: - can be |
| // retrieved from [OpenID |
| // Discovery](https://openid.net/specs/openid-connect-discovery-1_0.html |
| // of the issuer. - can be inferred from the email domain of the issuer |
| // (e.g. a Google service account). Example: |
| // https://www.googleapis.com/oauth2/v1/certs |
| JwksUri string `json:"jwksUri,omitempty"` |
| |
| // JwtLocations: Defines the locations to extract the JWT. JWT locations |
| // can be either from HTTP headers or URL query parameters. The rule is |
| // that the first match wins. The checking order is: checking all |
| // headers first, then URL query parameters. If not specified, default |
| // to use following 3 locations: 1) Authorization: Bearer 2) |
| // x-goog-iap-jwt-assertion 3) access_token query parameter Default |
| // locations can be specified as followings: jwt_locations: - header: |
| // Authorization value_prefix: "Bearer " - header: |
| // x-goog-iap-jwt-assertion - query: access_token |
| JwtLocations []*JwtLocation `json:"jwtLocations,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Audiences") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Audiences") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *AuthProvider) MarshalJSON() ([]byte, error) { |
| type NoMethod AuthProvider |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // AuthRequirement: User-defined authentication requirements, including |
| // support for [JSON Web Token |
| // (JWT)](https://tools.ietf.org/html/draft-ietf-oauth-json-web-token-32) |
| // . |
| type AuthRequirement struct { |
| // Audiences: NOTE: This will be deprecated soon, once |
| // AuthProvider.audiences is implemented and accepted in all the runtime |
| // components. The list of JWT |
| // [audiences](https://tools.ietf.org/html/draft-ietf-oauth-json-web-toke |
| // n-32#section-4.1.3). that are allowed to access. A JWT containing any |
| // of these audiences will be accepted. When this setting is absent, |
| // only JWTs with audience "https://Service_name/API_name" will be |
| // accepted. For example, if no audiences are in the setting, |
| // LibraryService API will only accept JWTs with the following audience |
| // "https://library-example.googleapis.com/google.example.library.v1.Libr |
| // aryService". Example: audiences: |
| // bookstore_android.apps.googleusercontent.com, |
| // bookstore_web.apps.googleusercontent.com |
| Audiences string `json:"audiences,omitempty"` |
| |
| // ProviderId: id from authentication provider. Example: provider_id: |
| // bookstore_auth |
| ProviderId string `json:"providerId,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Audiences") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Audiences") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *AuthRequirement) MarshalJSON() ([]byte, error) { |
| type NoMethod AuthRequirement |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Authentication: `Authentication` defines the authentication |
| // configuration for an API. Example for an API targeted for external |
| // use: name: calendar.googleapis.com authentication: providers: - id: |
| // google_calendar_auth jwks_uri: |
| // https://www.googleapis.com/oauth2/v1/certs issuer: |
| // https://securetoken.google.com rules: - selector: "*" requirements: |
| // provider_id: google_calendar_auth |
| type Authentication struct { |
| // Providers: Defines a set of authentication providers that a service |
| // supports. |
| Providers []*AuthProvider `json:"providers,omitempty"` |
| |
| // Rules: A list of authentication rules that apply to individual API |
| // methods. **NOTE:** All service configuration rules follow "last one |
| // wins" order. |
| Rules []*AuthenticationRule `json:"rules,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Providers") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Providers") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Authentication) MarshalJSON() ([]byte, error) { |
| type NoMethod Authentication |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // AuthenticationRule: Authentication rules for the service. By default, |
| // if a method has any authentication requirements, every request must |
| // include a valid credential matching one of the requirements. It's an |
| // error to include more than one kind of credential in a single |
| // request. If a method doesn't have any auth requirements, request |
| // credentials will be ignored. |
| type AuthenticationRule struct { |
| // AllowWithoutCredential: If true, the service accepts API keys without |
| // any other credential. |
| AllowWithoutCredential bool `json:"allowWithoutCredential,omitempty"` |
| |
| // Oauth: The requirements for OAuth credentials. |
| Oauth *OAuthRequirements `json:"oauth,omitempty"` |
| |
| // Requirements: Requirements for additional authentication providers. |
| Requirements []*AuthRequirement `json:"requirements,omitempty"` |
| |
| // Selector: Selects the methods to which this rule applies. Refer to |
| // selector for syntax details. |
| Selector string `json:"selector,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. |
| // "AllowWithoutCredential") to unconditionally include in API requests. |
| // By default, fields with empty values are omitted from API requests. |
| // However, any non-pointer, non-interface field appearing in |
| // ForceSendFields will be sent to the server regardless of whether the |
| // field is empty or not. This may be used to include empty fields in |
| // Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "AllowWithoutCredential") |
| // to include in API requests with the JSON null value. By default, |
| // fields with empty values are omitted from API requests. However, any |
| // field with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *AuthenticationRule) MarshalJSON() ([]byte, error) { |
| type NoMethod AuthenticationRule |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Backend: `Backend` defines the backend configuration for a service. |
| type Backend struct { |
| // Rules: A list of API backend rules that apply to individual API |
| // methods. **NOTE:** All service configuration rules follow "last one |
| // wins" order. |
| Rules []*BackendRule `json:"rules,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Rules") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Rules") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Backend) MarshalJSON() ([]byte, error) { |
| type NoMethod Backend |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // BackendRule: A backend rule provides configuration for an individual |
| // API element. |
| type BackendRule struct { |
| // Address: The address of the API backend. The scheme is used to |
| // determine the backend protocol and security. The following schemes |
| // are accepted: SCHEME PROTOCOL SECURITY http:// HTTP None https:// |
| // HTTP TLS grpc:// gRPC None grpcs:// gRPC TLS It is recommended to |
| // explicitly include a scheme. Leaving out the scheme may cause |
| // constrasting behaviors across platforms. If the port is unspecified, |
| // the default is: - 80 for schemes without TLS - 443 for schemes with |
| // TLS For HTTP backends, use protocol to specify the protocol version. |
| Address string `json:"address,omitempty"` |
| |
| // Deadline: The number of seconds to wait for a response from a |
| // request. The default varies based on the request protocol and |
| // deployment environment. |
| Deadline float64 `json:"deadline,omitempty"` |
| |
| // DisableAuth: When disable_auth is true, a JWT ID token won't be |
| // generated and the original "Authorization" HTTP header will be |
| // preserved. If the header is used to carry the original token and is |
| // expected by the backend, this field must be set to true to preserve |
| // the header. |
| DisableAuth bool `json:"disableAuth,omitempty"` |
| |
| // JwtAudience: The JWT audience is used when generating a JWT ID token |
| // for the backend. This ID token will be added in the HTTP |
| // "authorization" header, and sent to the backend. |
| JwtAudience string `json:"jwtAudience,omitempty"` |
| |
| // MinDeadline: Minimum deadline in seconds needed for this method. |
| // Calls having deadline value lower than this will be rejected. |
| MinDeadline float64 `json:"minDeadline,omitempty"` |
| |
| // OperationDeadline: The number of seconds to wait for the completion |
| // of a long running operation. The default is no deadline. |
| OperationDeadline float64 `json:"operationDeadline,omitempty"` |
| |
| // Possible values: |
| // "PATH_TRANSLATION_UNSPECIFIED" |
| // "CONSTANT_ADDRESS" - Use the backend address as-is, with no |
| // modification to the path. If the URL pattern contains variables, the |
| // variable names and values will be appended to the query string. If a |
| // query string parameter and a URL pattern variable have the same name, |
| // this may result in duplicate keys in the query string. # Examples |
| // Given the following operation config: Method path: |
| // /api/company/{cid}/user/{uid} Backend address: |
| // https://example.cloudfunctions.net/getUser Requests to the following |
| // request paths will call the backend at the translated path: Request |
| // path: /api/company/widgetworks/user/johndoe Translated: |
| // https://example.cloudfunctions.net/getUser?cid=widgetworks&uid=johndoe Request path: /api/company/widgetworks/user/johndoe?timezone=EST Translated: |
| // https://example.cloudfunctions.net/getUser?timezone=EST&cid=widgetworks&uid=johndoe |
| // "APPEND_PATH_TO_ADDRESS" - The request path will be appended to the |
| // backend address. # Examples Given the following operation config: |
| // Method path: /api/company/{cid}/user/{uid} Backend address: |
| // https://example.appspot.com Requests to the following request paths |
| // will call the backend at the translated path: Request path: |
| // /api/company/widgetworks/user/johndoe Translated: |
| // https://example.appspot.com/api/company/widgetworks/user/johndoe |
| // Request path: /api/company/widgetworks/user/johndoe?timezone=EST |
| // Translated: |
| // https://example.appspot.com/api/company/widgetworks/user/johndoe?timezone=EST |
| PathTranslation string `json:"pathTranslation,omitempty"` |
| |
| // Protocol: The protocol used for sending a request to the backend. The |
| // supported values are "http/1.1" and "h2". The default value is |
| // inferred from the scheme in the address field: SCHEME PROTOCOL |
| // http:// http/1.1 https:// http/1.1 grpc:// h2 grpcs:// h2 For secure |
| // HTTP backends (https://) that support HTTP/2, set this field to "h2" |
| // for improved performance. Configuring this field to non-default |
| // values is only supported for secure HTTP backends. This field will be |
| // ignored for all other backends. See |
| // https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids for more details on the supported |
| // values. |
| Protocol string `json:"protocol,omitempty"` |
| |
| // Selector: Selects the methods to which this rule applies. Refer to |
| // selector for syntax details. |
| Selector string `json:"selector,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Address") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Address") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *BackendRule) MarshalJSON() ([]byte, error) { |
| type NoMethod BackendRule |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| func (s *BackendRule) UnmarshalJSON(data []byte) error { |
| type NoMethod BackendRule |
| var s1 struct { |
| Deadline gensupport.JSONFloat64 `json:"deadline"` |
| MinDeadline gensupport.JSONFloat64 `json:"minDeadline"` |
| OperationDeadline gensupport.JSONFloat64 `json:"operationDeadline"` |
| *NoMethod |
| } |
| s1.NoMethod = (*NoMethod)(s) |
| if err := json.Unmarshal(data, &s1); err != nil { |
| return err |
| } |
| s.Deadline = float64(s1.Deadline) |
| s.MinDeadline = float64(s1.MinDeadline) |
| s.OperationDeadline = float64(s1.OperationDeadline) |
| return nil |
| } |
| |
| // Billing: Billing related configuration of the service. The following |
| // example shows how to configure monitored resources and metrics for |
| // billing, `consumer_destinations` is the only supported destination |
| // and the monitored resources need at least one label key |
| // `cloud.googleapis.com/location` to indicate the location of the |
| // billing usage, using different monitored resources between monitoring |
| // and billing is recommended so they can be evolved independently: |
| // monitored_resources: - type: library.googleapis.com/billing_branch |
| // labels: - key: cloud.googleapis.com/location description: | |
| // Predefined label to support billing location restriction. - key: city |
| // description: | Custom label to define the city where the library |
| // branch is located in. - key: name description: Custom label to define |
| // the name of the library branch. metrics: - name: |
| // library.googleapis.com/book/borrowed_count metric_kind: DELTA |
| // value_type: INT64 unit: "1" billing: consumer_destinations: - |
| // monitored_resource: library.googleapis.com/billing_branch metrics: - |
| // library.googleapis.com/book/borrowed_count |
| type Billing struct { |
| // ConsumerDestinations: Billing configurations for sending metrics to |
| // the consumer project. There can be multiple consumer destinations per |
| // service, each one must have a different monitored resource type. A |
| // metric can be used in at most one consumer destination. |
| ConsumerDestinations []*BillingDestination `json:"consumerDestinations,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. |
| // "ConsumerDestinations") to unconditionally include in API requests. |
| // By default, fields with empty values are omitted from API requests. |
| // However, any non-pointer, non-interface field appearing in |
| // ForceSendFields will be sent to the server regardless of whether the |
| // field is empty or not. This may be used to include empty fields in |
| // Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "ConsumerDestinations") to |
| // include in API requests with the JSON null value. By default, fields |
| // with empty values are omitted from API requests. However, any field |
| // with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Billing) MarshalJSON() ([]byte, error) { |
| type NoMethod Billing |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // BillingDestination: Configuration of a specific billing destination |
| // (Currently only support bill against consumer project). |
| type BillingDestination struct { |
| // Metrics: Names of the metrics to report to this billing destination. |
| // Each name must be defined in Service.metrics section. |
| Metrics []string `json:"metrics,omitempty"` |
| |
| // MonitoredResource: The monitored resource type. The type must be |
| // defined in Service.monitored_resources section. |
| MonitoredResource string `json:"monitoredResource,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Metrics") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Metrics") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *BillingDestination) MarshalJSON() ([]byte, error) { |
| type NoMethod BillingDestination |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Binding: Associates `members` with a `role`. |
| type Binding struct { |
| // Condition: 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-p |
| // olicies). |
| Condition *Expr `json:"condition,omitempty"` |
| |
| // Members: 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`. |
| Members []string `json:"members,omitempty"` |
| |
| // Role: Role that is assigned to `members`. For example, |
| // `roles/viewer`, `roles/editor`, or `roles/owner`. |
| Role string `json:"role,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Condition") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Condition") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Binding) MarshalJSON() ([]byte, error) { |
| type NoMethod Binding |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ChangeReport: Change report associated with a particular service |
| // configuration. It contains a list of ConfigChanges based on the |
| // comparison between two service configurations. |
| type ChangeReport struct { |
| // ConfigChanges: List of changes between two service configurations. |
| // The changes will be alphabetically sorted based on the identifier of |
| // each change. A ConfigChange identifier is a dot separated path to the |
| // configuration. Example: |
| // visibility.rules[selector='LibraryService.CreateBook'].restriction |
| ConfigChanges []*ConfigChange `json:"configChanges,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "ConfigChanges") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "ConfigChanges") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ChangeReport) MarshalJSON() ([]byte, error) { |
| type NoMethod ChangeReport |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ConfigChange: Output generated from semantically comparing two |
| // versions of a service configuration. Includes detailed information |
| // about a field that have changed with applicable advice about |
| // potential consequences for the change, such as |
| // backwards-incompatibility. |
| type ConfigChange struct { |
| // Advices: Collection of advice provided for this change, useful for |
| // determining the possible impact of this change. |
| Advices []*Advice `json:"advices,omitempty"` |
| |
| // ChangeType: The type for this change, either ADDED, REMOVED, or |
| // MODIFIED. |
| // |
| // Possible values: |
| // "CHANGE_TYPE_UNSPECIFIED" - No value was provided. |
| // "ADDED" - The changed object exists in the 'new' service |
| // configuration, but not in the 'old' service configuration. |
| // "REMOVED" - The changed object exists in the 'old' service |
| // configuration, but not in the 'new' service configuration. |
| // "MODIFIED" - The changed object exists in both service |
| // configurations, but its value is different. |
| ChangeType string `json:"changeType,omitempty"` |
| |
| // Element: Object hierarchy path to the change, with levels separated |
| // by a '.' character. For repeated fields, an applicable unique |
| // identifier field is used for the index (usually selector, name, or |
| // id). For maps, the term 'key' is used. If the field has no unique |
| // identifier, the numeric index is used. Examples: - |
| // visibility.rules[selector=="google.LibraryService.ListBooks"].restrict |
| // ion - |
| // quota.metric_rules[selector=="google"].metric_costs[key=="reads"].valu |
| // e - logging.producer_destinations[0] |
| Element string `json:"element,omitempty"` |
| |
| // NewValue: Value of the changed object in the new Service |
| // configuration, in JSON format. This field will not be populated if |
| // ChangeType == REMOVED. |
| NewValue string `json:"newValue,omitempty"` |
| |
| // OldValue: Value of the changed object in the old Service |
| // configuration, in JSON format. This field will not be populated if |
| // ChangeType == ADDED. |
| OldValue string `json:"oldValue,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Advices") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Advices") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ConfigChange) MarshalJSON() ([]byte, error) { |
| type NoMethod ConfigChange |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ConfigFile: Generic specification of a source configuration file |
| type ConfigFile struct { |
| // FileContents: The bytes that constitute the file. |
| FileContents string `json:"fileContents,omitempty"` |
| |
| // FilePath: The file name of the configuration file (full or relative |
| // path). |
| FilePath string `json:"filePath,omitempty"` |
| |
| // FileType: The type of configuration file this represents. |
| // |
| // Possible values: |
| // "FILE_TYPE_UNSPECIFIED" - Unknown file type. |
| // "SERVICE_CONFIG_YAML" - YAML-specification of service. |
| // "OPEN_API_JSON" - OpenAPI specification, serialized in JSON. |
| // "OPEN_API_YAML" - OpenAPI specification, serialized in YAML. |
| // "FILE_DESCRIPTOR_SET_PROTO" - FileDescriptorSet, generated by |
| // protoc. To generate, use protoc with imports and source info |
| // included. For an example test.proto file, the following command would |
| // put the value in a new file named out.pb. $protoc --include_imports |
| // --include_source_info test.proto -o out.pb |
| // "PROTO_FILE" - Uncompiled Proto file. Used for storage and display |
| // purposes only, currently server-side compilation is not supported. |
| // Should match the inputs to 'protoc' command used to generated |
| // FILE_DESCRIPTOR_SET_PROTO. A file of this type can only be included |
| // if at least one file of type FILE_DESCRIPTOR_SET_PROTO is included. |
| FileType string `json:"fileType,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "FileContents") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "FileContents") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ConfigFile) MarshalJSON() ([]byte, error) { |
| type NoMethod ConfigFile |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ConfigRef: Represents a service configuration with its name and id. |
| type ConfigRef struct { |
| // Name: Resource name of a service config. It must have the following |
| // format: "services/{service name}/configs/{config id}". |
| Name string `json:"name,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Name") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Name") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ConfigRef) MarshalJSON() ([]byte, error) { |
| type NoMethod ConfigRef |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ConfigSource: Represents a source file which is used to generate the |
| // service configuration defined by `google.api.Service`. |
| type ConfigSource struct { |
| // Files: Set of source configuration files that are used to generate a |
| // service configuration (`google.api.Service`). |
| Files []*ConfigFile `json:"files,omitempty"` |
| |
| // Id: A unique ID for a specific instance of this message, typically |
| // assigned by the client for tracking purpose. If empty, the server may |
| // choose to generate one instead. |
| Id string `json:"id,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Files") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Files") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ConfigSource) MarshalJSON() ([]byte, error) { |
| type NoMethod ConfigSource |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Context: `Context` defines which contexts an API requests. Example: |
| // context: rules: - selector: "*" requested: - |
| // google.rpc.context.ProjectContext - google.rpc.context.OriginContext |
| // The above specifies that all methods in the API request |
| // `google.rpc.context.ProjectContext` and |
| // `google.rpc.context.OriginContext`. Available context types are |
| // defined in package `google.rpc.context`. This also provides mechanism |
| // to whitelist any protobuf message extension that can be sent in grpc |
| // metadata using “x-goog-ext--bin” and “x-goog-ext--jspb” |
| // format. For example, list any service specific protobuf types that |
| // can appear in grpc metadata as follows in your yaml file: Example: |
| // context: rules: - selector: |
| // "google.example.library.v1.LibraryService.CreateBook" |
| // allowed_request_extensions: - google.foo.v1.NewExtension |
| // allowed_response_extensions: - google.foo.v1.NewExtension You can |
| // also specify extension ID instead of fully qualified extension name |
| // here. |
| type Context struct { |
| // Rules: A list of RPC context rules that apply to individual API |
| // methods. **NOTE:** All service configuration rules follow "last one |
| // wins" order. |
| Rules []*ContextRule `json:"rules,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Rules") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Rules") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Context) MarshalJSON() ([]byte, error) { |
| type NoMethod Context |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ContextRule: A context rule provides information about the context |
| // for an individual API element. |
| type ContextRule struct { |
| // AllowedRequestExtensions: A list of full type names or extension IDs |
| // of extensions allowed in grpc side channel from client to backend. |
| AllowedRequestExtensions []string `json:"allowedRequestExtensions,omitempty"` |
| |
| // AllowedResponseExtensions: A list of full type names or extension IDs |
| // of extensions allowed in grpc side channel from backend to client. |
| AllowedResponseExtensions []string `json:"allowedResponseExtensions,omitempty"` |
| |
| // Provided: A list of full type names of provided contexts. |
| Provided []string `json:"provided,omitempty"` |
| |
| // Requested: A list of full type names of requested contexts. |
| Requested []string `json:"requested,omitempty"` |
| |
| // Selector: Selects the methods to which this rule applies. Refer to |
| // selector for syntax details. |
| Selector string `json:"selector,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. |
| // "AllowedRequestExtensions") to unconditionally include in API |
| // requests. By default, fields with empty values are omitted from API |
| // requests. However, any non-pointer, non-interface field appearing in |
| // ForceSendFields will be sent to the server regardless of whether the |
| // field is empty or not. This may be used to include empty fields in |
| // Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "AllowedRequestExtensions") |
| // to include in API requests with the JSON null value. By default, |
| // fields with empty values are omitted from API requests. However, any |
| // field with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ContextRule) MarshalJSON() ([]byte, error) { |
| type NoMethod ContextRule |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Control: Selects and configures the service controller used by the |
| // service. The service controller handles features like abuse, quota, |
| // billing, logging, monitoring, etc. |
| type Control struct { |
| // Environment: The service control environment to use. If empty, no |
| // control plane feature (like quota and billing) will be enabled. |
| Environment string `json:"environment,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Environment") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Environment") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Control) MarshalJSON() ([]byte, error) { |
| type NoMethod Control |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // CustomError: Customize service error responses. For example, list any |
| // service specific protobuf types that can appear in error detail lists |
| // of error responses. Example: custom_error: types: - |
| // google.foo.v1.CustomError - google.foo.v1.AnotherError |
| type CustomError struct { |
| // Rules: The list of custom error rules that apply to individual API |
| // messages. **NOTE:** All service configuration rules follow "last one |
| // wins" order. |
| Rules []*CustomErrorRule `json:"rules,omitempty"` |
| |
| // Types: The list of custom error detail types, e.g. |
| // 'google.foo.v1.CustomError'. |
| Types []string `json:"types,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Rules") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Rules") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *CustomError) MarshalJSON() ([]byte, error) { |
| type NoMethod CustomError |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // CustomErrorRule: A custom error rule. |
| type CustomErrorRule struct { |
| // IsErrorType: Mark this message as possible payload in error response. |
| // Otherwise, objects of this type will be filtered when they appear in |
| // error payload. |
| IsErrorType bool `json:"isErrorType,omitempty"` |
| |
| // Selector: Selects messages to which this rule applies. Refer to |
| // selector for syntax details. |
| Selector string `json:"selector,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "IsErrorType") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "IsErrorType") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *CustomErrorRule) MarshalJSON() ([]byte, error) { |
| type NoMethod CustomErrorRule |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // CustomHttpPattern: A custom pattern is used for defining custom HTTP |
| // verb. |
| type CustomHttpPattern struct { |
| // Kind: The name of this custom HTTP verb. |
| Kind string `json:"kind,omitempty"` |
| |
| // Path: The path matched by this custom verb. |
| Path string `json:"path,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Kind") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Kind") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *CustomHttpPattern) MarshalJSON() ([]byte, error) { |
| type NoMethod CustomHttpPattern |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // DeleteServiceStrategy: Strategy used to delete a service. This |
| // strategy is a placeholder only used by the system generated rollout |
| // to delete a service. |
| type DeleteServiceStrategy struct { |
| } |
| |
| // Diagnostic: Represents a diagnostic message (error or warning) |
| type Diagnostic struct { |
| // Kind: The kind of diagnostic information provided. |
| // |
| // Possible values: |
| // "WARNING" - Warnings and errors |
| // "ERROR" - Only errors |
| Kind string `json:"kind,omitempty"` |
| |
| // Location: File name and line number of the error or warning. |
| Location string `json:"location,omitempty"` |
| |
| // Message: Message describing the error or warning. |
| Message string `json:"message,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Kind") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Kind") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Diagnostic) MarshalJSON() ([]byte, error) { |
| type NoMethod Diagnostic |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // DisableServiceResponse: Operation payload for DisableService method. |
| type DisableServiceResponse struct { |
| } |
| |
| // Documentation: `Documentation` provides the information for |
| // describing a service. Example: documentation: summary: > The Google |
| // Calendar API gives access to most calendar features. pages: - name: |
| // Overview content: (== include google/foo/overview.md ==) - name: |
| // Tutorial content: (== include google/foo/tutorial.md ==) subpages; - |
| // name: Java content: (== include google/foo/tutorial_java.md ==) |
| // rules: - selector: google.calendar.Calendar.Get description: > ... - |
| // selector: google.calendar.Calendar.Put description: > ... |
| // Documentation is provided in markdown syntax. In addition to standard |
| // markdown features, definition lists, tables and fenced code blocks |
| // are supported. Section headers can be provided and are interpreted |
| // relative to the section nesting of the context where a documentation |
| // fragment is embedded. Documentation from the IDL is merged with |
| // documentation defined via the config at normalization time, where |
| // documentation provided by config rules overrides IDL provided. A |
| // number of constructs specific to the API platform are supported in |
| // documentation text. In order to reference a proto element, the |
| // following notation can be used: [fully.qualified.proto.name][] To |
| // override the display text used for the link, this can be used: |
| // [display text][fully.qualified.proto.name] Text can be excluded from |
| // doc using the following notation: (-- internal comment --) A few |
| // directives are available in documentation. Note that directives must |
| // appear on a single line to be properly identified. The `include` |
| // directive includes a markdown file from an external source: (== |
| // include path/to/file ==) The `resource_for` directive marks a message |
| // to be the resource of a collection in REST view. If it is not |
| // specified, tools attempt to infer the resource from the operations in |
| // a collection: (== resource_for v1.shelves.books ==) The directive |
| // `suppress_warning` does not directly affect documentation and is |
| // documented together with service config validation. |
| type Documentation struct { |
| // DocumentationRootUrl: The URL to the root of documentation. |
| DocumentationRootUrl string `json:"documentationRootUrl,omitempty"` |
| |
| // Overview: Declares a single overview page. For example: |
| // documentation: summary: ... overview: (== include overview.md ==) |
| // This is a shortcut for the following declaration (using pages style): |
| // documentation: summary: ... pages: - name: Overview content: (== |
| // include overview.md ==) Note: you cannot specify both `overview` |
| // field and `pages` field. |
| Overview string `json:"overview,omitempty"` |
| |
| // Pages: The top level pages for the documentation set. |
| Pages []*Page `json:"pages,omitempty"` |
| |
| // Rules: A list of documentation rules that apply to individual API |
| // elements. **NOTE:** All service configuration rules follow "last one |
| // wins" order. |
| Rules []*DocumentationRule `json:"rules,omitempty"` |
| |
| // ServiceRootUrl: Specifies the service root url if the default one |
| // (the service name from the yaml file) is not suitable. This can be |
| // seen in any fully specified service urls as well as sections that |
| // show a base that other urls are relative to. |
| ServiceRootUrl string `json:"serviceRootUrl,omitempty"` |
| |
| // Summary: A short summary of what the service does. Can only be |
| // provided by plain text. |
| Summary string `json:"summary,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. |
| // "DocumentationRootUrl") to unconditionally include in API requests. |
| // By default, fields with empty values are omitted from API requests. |
| // However, any non-pointer, non-interface field appearing in |
| // ForceSendFields will be sent to the server regardless of whether the |
| // field is empty or not. This may be used to include empty fields in |
| // Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "DocumentationRootUrl") to |
| // include in API requests with the JSON null value. By default, fields |
| // with empty values are omitted from API requests. However, any field |
| // with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Documentation) MarshalJSON() ([]byte, error) { |
| type NoMethod Documentation |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // DocumentationRule: A documentation rule provides information about |
| // individual API elements. |
| type DocumentationRule struct { |
| // DeprecationDescription: Deprecation description of the selected |
| // element(s). It can be provided if an element is marked as |
| // `deprecated`. |
| DeprecationDescription string `json:"deprecationDescription,omitempty"` |
| |
| // Description: Description of the selected API(s). |
| Description string `json:"description,omitempty"` |
| |
| // Selector: The selector is a comma-separated list of patterns. Each |
| // pattern is a qualified name of the element which may end in "*", |
| // indicating a wildcard. Wildcards are only allowed at the end and for |
| // a whole component of the qualified name, i.e. "foo.*" is ok, but not |
| // "foo.b*" or "foo.*.bar". A wildcard will match one or more |
| // components. To specify a default for all applicable elements, the |
| // whole pattern "*" is used. |
| Selector string `json:"selector,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. |
| // "DeprecationDescription") to unconditionally include in API requests. |
| // By default, fields with empty values are omitted from API requests. |
| // However, any non-pointer, non-interface field appearing in |
| // ForceSendFields will be sent to the server regardless of whether the |
| // field is empty or not. This may be used to include empty fields in |
| // Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "DeprecationDescription") |
| // to include in API requests with the JSON null value. By default, |
| // fields with empty values are omitted from API requests. However, any |
| // field with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *DocumentationRule) MarshalJSON() ([]byte, error) { |
| type NoMethod DocumentationRule |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // EnableServiceRequest: Request message for EnableService method. |
| type EnableServiceRequest struct { |
| // ConsumerId: Required. The identity of consumer resource which service |
| // enablement will be applied to. The Google Service Management |
| // implementation accepts the following forms: - "project:" Note: this |
| // is made compatible with |
| // google.api.servicecontrol.v1.Operation.consumer_id. |
| ConsumerId string `json:"consumerId,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "ConsumerId") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "ConsumerId") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *EnableServiceRequest) MarshalJSON() ([]byte, error) { |
| type NoMethod EnableServiceRequest |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // EnableServiceResponse: Operation payload for EnableService method. |
| type EnableServiceResponse struct { |
| } |
| |
| // Endpoint: `Endpoint` describes a network endpoint that serves a set |
| // of APIs. A service may expose any number of endpoints, and all |
| // endpoints share the same service configuration, such as quota |
| // configuration and monitoring configuration. Example service |
| // configuration: name: library-example.googleapis.com endpoints: # |
| // Below entry makes 'google.example.library.v1.Library' # API be served |
| // from endpoint address library-example.googleapis.com. # It also |
| // allows HTTP OPTIONS calls to be passed to the backend, for # it to |
| // decide whether the subsequent cross-origin request is # allowed to |
| // proceed. - name: library-example.googleapis.com allow_cors: true |
| type Endpoint struct { |
| // Aliases: DEPRECATED: This field is no longer supported. Instead of |
| // using aliases, please specify multiple google.api.Endpoint for each |
| // of the intended aliases. Additional names that this endpoint will be |
| // hosted on. |
| Aliases []string `json:"aliases,omitempty"` |
| |
| // AllowCors: Allowing |
| // [CORS](https://en.wikipedia.org/wiki/Cross-origin_resource_sharing), |
| // aka cross-domain traffic, would allow the backends served from this |
| // endpoint to receive and respond to HTTP OPTIONS requests. The |
| // response will be used by the browser to determine whether the |
| // subsequent cross-origin request is allowed to proceed. |
| AllowCors bool `json:"allowCors,omitempty"` |
| |
| // Name: The canonical name of this endpoint. |
| Name string `json:"name,omitempty"` |
| |
| // Target: The specification of an Internet routable address of API |
| // frontend that will handle requests to this [API |
| // Endpoint](https://cloud.google.com/apis/design/glossary). It should |
| // be either a valid IPv4 address or a fully-qualified domain name. For |
| // example, "8.8.8.8" or "myservice.appspot.com". |
| Target string `json:"target,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Aliases") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Aliases") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Endpoint) MarshalJSON() ([]byte, error) { |
| type NoMethod Endpoint |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Enum: Enum type definition. |
| type Enum struct { |
| // Enumvalue: Enum value definitions. |
| Enumvalue []*EnumValue `json:"enumvalue,omitempty"` |
| |
| // Name: Enum type name. |
| Name string `json:"name,omitempty"` |
| |
| // Options: Protocol buffer options. |
| Options []*Option `json:"options,omitempty"` |
| |
| // SourceContext: The source context. |
| SourceContext *SourceContext `json:"sourceContext,omitempty"` |
| |
| // Syntax: The source syntax. |
| // |
| // Possible values: |
| // "SYNTAX_PROTO2" - Syntax `proto2`. |
| // "SYNTAX_PROTO3" - Syntax `proto3`. |
| Syntax string `json:"syntax,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Enumvalue") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Enumvalue") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Enum) MarshalJSON() ([]byte, error) { |
| type NoMethod Enum |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // EnumValue: Enum value definition. |
| type EnumValue struct { |
| // Name: Enum value name. |
| Name string `json:"name,omitempty"` |
| |
| // Number: Enum value number. |
| Number int64 `json:"number,omitempty"` |
| |
| // Options: Protocol buffer options. |
| Options []*Option `json:"options,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Name") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Name") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *EnumValue) MarshalJSON() ([]byte, error) { |
| type NoMethod EnumValue |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Expr: 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. |
| type Expr struct { |
| // Description: Optional. Description of the expression. This is a |
| // longer text which describes the expression, e.g. when hovered over it |
| // in a UI. |
| Description string `json:"description,omitempty"` |
| |
| // Expression: Textual representation of an expression in Common |
| // Expression Language syntax. |
| Expression string `json:"expression,omitempty"` |
| |
| // Location: Optional. String indicating the location of the expression |
| // for error reporting, e.g. a file name and a position in the file. |
| Location string `json:"location,omitempty"` |
| |
| // Title: Optional. 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. |
| Title string `json:"title,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Description") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Description") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Expr) MarshalJSON() ([]byte, error) { |
| type NoMethod Expr |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Field: A single field of a message type. |
| type Field struct { |
| // Cardinality: The field cardinality. |
| // |
| // Possible values: |
| // "CARDINALITY_UNKNOWN" - For fields with unknown cardinality. |
| // "CARDINALITY_OPTIONAL" - For optional fields. |
| // "CARDINALITY_REQUIRED" - For required fields. Proto2 syntax only. |
| // "CARDINALITY_REPEATED" - For repeated fields. |
| Cardinality string `json:"cardinality,omitempty"` |
| |
| // DefaultValue: The string value of the default value of this field. |
| // Proto2 syntax only. |
| DefaultValue string `json:"defaultValue,omitempty"` |
| |
| // JsonName: The field JSON name. |
| JsonName string `json:"jsonName,omitempty"` |
| |
| // Kind: The field type. |
| // |
| // Possible values: |
| // "TYPE_UNKNOWN" - Field type unknown. |
| // "TYPE_DOUBLE" - Field type double. |
| // "TYPE_FLOAT" - Field type float. |
| // "TYPE_INT64" - Field type int64. |
| // "TYPE_UINT64" - Field type uint64. |
| // "TYPE_INT32" - Field type int32. |
| // "TYPE_FIXED64" - Field type fixed64. |
| // "TYPE_FIXED32" - Field type fixed32. |
| // "TYPE_BOOL" - Field type bool. |
| // "TYPE_STRING" - Field type string. |
| // "TYPE_GROUP" - Field type group. Proto2 syntax only, and |
| // deprecated. |
| // "TYPE_MESSAGE" - Field type message. |
| // "TYPE_BYTES" - Field type bytes. |
| // "TYPE_UINT32" - Field type uint32. |
| // "TYPE_ENUM" - Field type enum. |
| // "TYPE_SFIXED32" - Field type sfixed32. |
| // "TYPE_SFIXED64" - Field type sfixed64. |
| // "TYPE_SINT32" - Field type sint32. |
| // "TYPE_SINT64" - Field type sint64. |
| Kind string `json:"kind,omitempty"` |
| |
| // Name: The field name. |
| Name string `json:"name,omitempty"` |
| |
| // Number: The field number. |
| Number int64 `json:"number,omitempty"` |
| |
| // OneofIndex: The index of the field type in `Type.oneofs`, for message |
| // or enumeration types. The first type has index 1; zero means the type |
| // is not in the list. |
| OneofIndex int64 `json:"oneofIndex,omitempty"` |
| |
| // Options: The protocol buffer options. |
| Options []*Option `json:"options,omitempty"` |
| |
| // Packed: Whether to use alternative packed wire representation. |
| Packed bool `json:"packed,omitempty"` |
| |
| // TypeUrl: The field type URL, without the scheme, for message or |
| // enumeration types. Example: |
| // "type.googleapis.com/google.protobuf.Timestamp". |
| TypeUrl string `json:"typeUrl,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Cardinality") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Cardinality") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Field) MarshalJSON() ([]byte, error) { |
| type NoMethod Field |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // FlowErrorDetails: Encapsulation of flow-specific error details for |
| // debugging. Used as a details field on an error Status, not intended |
| // for external use. |
| type FlowErrorDetails struct { |
| // ExceptionType: The type of exception (as a class name). |
| ExceptionType string `json:"exceptionType,omitempty"` |
| |
| // FlowStepId: The step that failed. |
| FlowStepId string `json:"flowStepId,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "ExceptionType") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "ExceptionType") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *FlowErrorDetails) MarshalJSON() ([]byte, error) { |
| type NoMethod FlowErrorDetails |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // GenerateConfigReportRequest: Request message for GenerateConfigReport |
| // method. |
| type GenerateConfigReportRequest struct { |
| // NewConfig: Required. Service configuration for which we want to |
| // generate the report. For this version of API, the supported types are |
| // google.api.servicemanagement.v1.ConfigRef, |
| // google.api.servicemanagement.v1.ConfigSource, and google.api.Service |
| NewConfig googleapi.RawMessage `json:"newConfig,omitempty"` |
| |
| // OldConfig: Optional. Service configuration against which the |
| // comparison will be done. For this version of API, the supported types |
| // are google.api.servicemanagement.v1.ConfigRef, |
| // google.api.servicemanagement.v1.ConfigSource, and google.api.Service |
| OldConfig googleapi.RawMessage `json:"oldConfig,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "NewConfig") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "NewConfig") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *GenerateConfigReportRequest) MarshalJSON() ([]byte, error) { |
| type NoMethod GenerateConfigReportRequest |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // GenerateConfigReportResponse: Response message for |
| // GenerateConfigReport method. |
| type GenerateConfigReportResponse struct { |
| // ChangeReports: list of ChangeReport, each corresponding to comparison |
| // between two service configurations. |
| ChangeReports []*ChangeReport `json:"changeReports,omitempty"` |
| |
| // Diagnostics: Errors / Linter warnings associated with the service |
| // definition this report belongs to. |
| Diagnostics []*Diagnostic `json:"diagnostics,omitempty"` |
| |
| // Id: ID of the service configuration this report belongs to. |
| Id string `json:"id,omitempty"` |
| |
| // ServiceName: Name of the service this report belongs to. |
| ServiceName string `json:"serviceName,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "ChangeReports") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "ChangeReports") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *GenerateConfigReportResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod GenerateConfigReportResponse |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // GetIamPolicyRequest: Request message for `GetIamPolicy` method. |
| type GetIamPolicyRequest struct { |
| // Options: OPTIONAL: A `GetPolicyOptions` object for specifying options |
| // to `GetIamPolicy`. |
| Options *GetPolicyOptions `json:"options,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Options") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Options") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *GetIamPolicyRequest) MarshalJSON() ([]byte, error) { |
| type NoMethod GetIamPolicyRequest |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // GetPolicyOptions: Encapsulates settings provided to GetIamPolicy. |
| type GetPolicyOptions struct { |
| // 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-p |
| // olicies). |
| RequestedPolicyVersion int64 `json:"requestedPolicyVersion,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. |
| // "RequestedPolicyVersion") to unconditionally include in API requests. |
| // By default, fields with empty values are omitted from API requests. |
| // However, any non-pointer, non-interface field appearing in |
| // ForceSendFields will be sent to the server regardless of whether the |
| // field is empty or not. This may be used to include empty fields in |
| // Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "RequestedPolicyVersion") |
| // to include in API requests with the JSON null value. By default, |
| // fields with empty values are omitted from API requests. However, any |
| // field with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *GetPolicyOptions) MarshalJSON() ([]byte, error) { |
| type NoMethod GetPolicyOptions |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Http: Defines the HTTP configuration for an API service. It contains |
| // a list of HttpRule, each specifying the mapping of an RPC method to |
| // one or more HTTP REST API methods. |
| type Http struct { |
| // FullyDecodeReservedExpansion: When set to true, URL path parameters |
| // will be fully URI-decoded except in cases of single segment matches |
| // in reserved expansion, where "%2F" will be left encoded. The default |
| // behavior is to not decode RFC 6570 reserved characters in multi |
| // segment matches. |
| FullyDecodeReservedExpansion bool `json:"fullyDecodeReservedExpansion,omitempty"` |
| |
| // Rules: A list of HTTP configuration rules that apply to individual |
| // API methods. **NOTE:** All service configuration rules follow "last |
| // one wins" order. |
| Rules []*HttpRule `json:"rules,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. |
| // "FullyDecodeReservedExpansion") to unconditionally include in API |
| // requests. By default, fields with empty values are omitted from API |
| // requests. However, any non-pointer, non-interface field appearing in |
| // ForceSendFields will be sent to the server regardless of whether the |
| // field is empty or not. This may be used to include empty fields in |
| // Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. |
| // "FullyDecodeReservedExpansion") to include in API requests with the |
| // JSON null value. By default, fields with empty values are omitted |
| // from API requests. However, any field with an empty value appearing |
| // in NullFields will be sent to the server as null. It is an error if a |
| // field in this list has a non-empty value. This may be used to include |
| // null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Http) MarshalJSON() ([]byte, error) { |
| type NoMethod Http |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // HttpRule: # gRPC Transcoding gRPC Transcoding is a feature for |
| // mapping between a gRPC method and one or more HTTP REST endpoints. It |
| // allows developers to build a single API service that supports both |
| // gRPC APIs and REST APIs. Many systems, including [Google |
| // APIs](https://github.com/googleapis/googleapis), [Cloud |
| // Endpoints](https://cloud.google.com/endpoints), [gRPC |
| // Gateway](https://github.com/grpc-ecosystem/grpc-gateway), and |
| // [Envoy](https://github.com/envoyproxy/envoy) proxy support this |
| // feature and use it for large scale production services. `HttpRule` |
| // defines the schema of the gRPC/REST mapping. The mapping specifies |
| // how different portions of the gRPC request message are mapped to the |
| // URL path, URL query parameters, and HTTP request body. It also |
| // controls how the gRPC response message is mapped to the HTTP response |
| // body. `HttpRule` is typically specified as an `google.api.http` |
| // annotation on the gRPC method. Each mapping specifies a URL path |
| // template and an HTTP method. The path template may refer to one or |
| // more fields in the gRPC request message, as long as each field is a |
| // non-repeated field with a primitive (non-message) type. The path |
| // template controls how fields of the request message are mapped to the |
| // URL path. Example: service Messaging { rpc |
| // GetMessage(GetMessageRequest) returns (Message) { option |
| // (google.api.http) = { get: "/v1/{name=messages/*}" }; } } message |
| // GetMessageRequest { string name = 1; // Mapped to URL path. } message |
| // Message { string text = 1; // The resource content. } This enables an |
| // HTTP REST to gRPC mapping as below: HTTP | gRPC -----|----- `GET |
| // /v1/messages/123456` | `GetMessage(name: "messages/123456")` Any |
| // fields in the request message which are not bound by the path |
| // template automatically become HTTP query parameters if there is no |
| // HTTP request body. For example: service Messaging { rpc |
| // GetMessage(GetMessageRequest) returns (Message) { option |
| // (google.api.http) = { get:"/v1/messages/{message_id}" }; } } message |
| // GetMessageRequest { message SubMessage { string subfield = 1; } |
| // string message_id = 1; // Mapped to URL path. int64 revision = 2; // |
| // Mapped to URL query parameter `revision`. SubMessage sub = 3; // |
| // Mapped to URL query parameter `sub.subfield`. } This enables a HTTP |
| // JSON to RPC mapping as below: HTTP | gRPC -----|----- `GET |
| // /v1/messages/123456?revision=2&sub.subfield=foo` | |
| // `GetMessage(message_id: "123456" revision: 2 sub: |
| // SubMessage(subfield: "foo"))` Note that fields which are mapped to |
| // URL query parameters must have a primitive type or a repeated |
| // primitive type or a non-repeated message type. In the case of a |
| // repeated type, the parameter can be repeated in the URL as |
| // `...?param=A¶m=B`. In the case of a message type, each field of |
| // the message is mapped to a separate parameter, such as |
| // `...?foo.a=A&foo.b=B&foo.c=C`. For HTTP methods that allow a request |
| // body, the `body` field specifies the mapping. Consider a REST update |
| // method on the message resource collection: service Messaging { rpc |
| // UpdateMessage(UpdateMessageRequest) returns (Message) { option |
| // (google.api.http) = { patch: "/v1/messages/{message_id}" body: |
| // "message" }; } } message UpdateMessageRequest { string message_id = |
| // 1; // mapped to the URL Message message = 2; // mapped to the body } |
| // The following HTTP JSON to RPC mapping is enabled, where the |
| // representation of the JSON in the request body is determined by |
| // protos JSON encoding: HTTP | gRPC -----|----- `PATCH |
| // /v1/messages/123456 { "text": "Hi!" }` | `UpdateMessage(message_id: |
| // "123456" message { text: "Hi!" })` The special name `*` can be used |
| // in the body mapping to define that every field not bound by the path |
| // template should be mapped to the request body. This enables the |
| // following alternative definition of the update method: service |
| // Messaging { rpc UpdateMessage(Message) returns (Message) { option |
| // (google.api.http) = { patch: "/v1/messages/{message_id}" body: "*" }; |
| // } } message Message { string message_id = 1; string text = 2; } The |
| // following HTTP JSON to RPC mapping is enabled: HTTP | gRPC |
| // -----|----- `PATCH /v1/messages/123456 { "text": "Hi!" }` | |
| // `UpdateMessage(message_id: "123456" text: "Hi!")` Note that when |
| // using `*` in the body mapping, it is not possible to have HTTP |
| // parameters, as all fields not bound by the path end in the body. This |
| // makes this option more rarely used in practice when defining REST |
| // APIs. The common usage of `*` is in custom methods which don't use |
| // the URL at all for transferring data. It is possible to define |
| // multiple HTTP methods for one RPC by using the `additional_bindings` |
| // option. Example: service Messaging { rpc |
| // GetMessage(GetMessageRequest) returns (Message) { option |
| // (google.api.http) = { get: "/v1/messages/{message_id}" |
| // additional_bindings { get: |
| // "/v1/users/{user_id}/messages/{message_id}" } }; } } message |
| // GetMessageRequest { string message_id = 1; string user_id = 2; } This |
| // enables the following two alternative HTTP JSON to RPC mappings: HTTP |
| // | gRPC -----|----- `GET /v1/messages/123456` | |
| // `GetMessage(message_id: "123456")` `GET /v1/users/me/messages/123456` |
| // | `GetMessage(user_id: "me" message_id: "123456")` ## Rules for HTTP |
| // mapping 1. Leaf request fields (recursive expansion nested messages |
| // in the request message) are classified into three categories: - |
| // Fields referred by the path template. They are passed via the URL |
| // path. - Fields referred by the HttpRule.body. They are passed via the |
| // HTTP request body. - All other fields are passed via the URL query |
| // parameters, and the parameter name is the field path in the request |
| // message. A repeated field can be represented as multiple query |
| // parameters under the same name. 2. If HttpRule.body is "*", there is |
| // no URL query parameter, all fields are passed via URL path and HTTP |
| // request body. 3. If HttpRule.body is omitted, there is no HTTP |
| // request body, all fields are passed via URL path and URL query |
| // parameters. ### Path template syntax Template = "/" Segments [ Verb ] |
| // ; Segments = Segment { "/" Segment } ; Segment = "*" | "**" | LITERAL |
| // | Variable ; Variable = "{" FieldPath [ "=" Segments ] "}" ; |
| // FieldPath = IDENT { "." IDENT } ; Verb = ":" LITERAL ; The syntax `*` |
| // matches a single URL path segment. The syntax `**` matches zero or |
| // more URL path segments, which must be the last part of the URL path |
| // except the `Verb`. The syntax `Variable` matches part of the URL path |
| // as specified by its template. A variable template must not contain |
| // other variables. If a variable matches a single path segment, its |
| // template may be omitted, e.g. `{var}` is equivalent to `{var=*}`. The |
| // syntax `LITERAL` matches literal text in the URL path. If the |
| // `LITERAL` contains any reserved character, such characters should be |
| // percent-encoded before the matching. If a variable contains exactly |
| // one path segment, such as "{var}" or "{var=*}", when such a |
| // variable is expanded into a URL path on the client side, all |
| // characters except `[-_.~0-9a-zA-Z]` are percent-encoded. The server |
| // side does the reverse decoding. Such variables show up in the |
| // [Discovery |
| // Document](https://developers.google.com/discovery/v1/reference/apis) |
| // as `{var}`. If a variable contains multiple path segments, such as |
| // "{var=foo/*}" or "{var=**}", when such a variable is expanded |
| // into a URL path on the client side, all characters except |
| // `[-_.~/0-9a-zA-Z]` are percent-encoded. The server side does the |
| // reverse decoding, except "%2F" and "%2f" are left unchanged. Such |
| // variables show up in the [Discovery |
| // Document](https://developers.google.com/discovery/v1/reference/apis) |
| // as `{+var}`. ## Using gRPC API Service Configuration gRPC API Service |
| // Configuration (service config) is a configuration language for |
| // configuring a gRPC service to become a user-facing product. The |
| // service config is simply the YAML representation of the |
| // `google.api.Service` proto message. As an alternative to annotating |
| // your proto file, you can configure gRPC transcoding in your service |
| // config YAML files. You do this by specifying a `HttpRule` that maps |
| // the gRPC method to a REST endpoint, achieving the same effect as the |
| // proto annotation. This can be particularly useful if you have a proto |
| // that is reused in multiple services. Note that any transcoding |
| // specified in the service config will override any matching |
| // transcoding configuration in the proto. Example: http: rules: # |
| // Selects a gRPC method and applies HttpRule to it. - selector: |
| // example.v1.Messaging.GetMessage get: |
| // /v1/messages/{message_id}/{sub.subfield} ## Special notes When gRPC |
| // Transcoding is used to map a gRPC to JSON REST endpoints, the proto |
| // to JSON conversion must follow the [proto3 |
| // specification](https://developers.google.com/protocol-buffers/docs/pro |
| // to3#json). While the single segment variable follows the semantics of |
| // [RFC 6570](https://tools.ietf.org/html/rfc6570) Section 3.2.2 Simple |
| // String Expansion, the multi segment variable **does not** follow RFC |
| // 6570 Section 3.2.3 Reserved Expansion. The reason is that the |
| // Reserved Expansion does not expand special characters like `?` and |
| // `#`, which would lead to invalid URLs. As the result, gRPC |
| // Transcoding uses a custom encoding for multi segment variables. The |
| // path variables **must not** refer to any repeated or mapped field, |
| // because client libraries are not capable of handling such variable |
| // expansion. The path variables **must not** capture the leading "/" |
| // character. The reason is that the most common use case "{var}" does |
| // not capture the leading "/" character. For consistency, all path |
| // variables must share the same behavior. Repeated message fields must |
| // not be mapped to URL query parameters, because no client library can |
| // support such complicated mapping. If an API needs to use a JSON array |
| // for request or response body, it can map the request or response body |
| // to a repeated field. However, some gRPC Transcoding implementations |
| // may not support this feature. |
| type HttpRule struct { |
| // AdditionalBindings: Additional HTTP bindings for the selector. Nested |
| // bindings must not contain an `additional_bindings` field themselves |
| // (that is, the nesting may only be one level deep). |
| AdditionalBindings []*HttpRule `json:"additionalBindings,omitempty"` |
| |
| // AllowHalfDuplex: When this flag is set to true, HTTP requests will be |
| // allowed to invoke a half-duplex streaming method. |
| AllowHalfDuplex bool `json:"allowHalfDuplex,omitempty"` |
| |
| // Body: The name of the request field whose value is mapped to the HTTP |
| // request body, or `*` for mapping all request fields not captured by |
| // the path pattern to the HTTP body, or omitted for not having any HTTP |
| // request body. NOTE: the referred field must be present at the |
| // top-level of the request message type. |
| Body string `json:"body,omitempty"` |
| |
| // Custom: The custom pattern is used for specifying an HTTP method that |
| // is not included in the `pattern` field, such as HEAD, or "*" to leave |
| // the HTTP method unspecified for this rule. The wild-card rule is |
| // useful for services that provide content to Web (HTML) clients. |
| Custom *CustomHttpPattern `json:"custom,omitempty"` |
| |
| // Delete: Maps to HTTP DELETE. Used for deleting a resource. |
| Delete string `json:"delete,omitempty"` |
| |
| // Get: Maps to HTTP GET. Used for listing and getting information about |
| // resources. |
| Get string `json:"get,omitempty"` |
| |
| // Patch: Maps to HTTP PATCH. Used for updating a resource. |
| Patch string `json:"patch,omitempty"` |
| |
| // Post: Maps to HTTP POST. Used for creating a resource or performing |
| // an action. |
| Post string `json:"post,omitempty"` |
| |
| // Put: Maps to HTTP PUT. Used for replacing a resource. |
| Put string `json:"put,omitempty"` |
| |
| // ResponseBody: Optional. The name of the response field whose value is |
| // mapped to the HTTP response body. When omitted, the entire response |
| // message will be used as the HTTP response body. NOTE: The referred |
| // field must be present at the top-level of the response message type. |
| ResponseBody string `json:"responseBody,omitempty"` |
| |
| // Selector: Selects a method to which this rule applies. Refer to |
| // selector for syntax details. |
| Selector string `json:"selector,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "AdditionalBindings") |
| // to unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "AdditionalBindings") to |
| // include in API requests with the JSON null value. By default, fields |
| // with empty values are omitted from API requests. However, any field |
| // with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *HttpRule) MarshalJSON() ([]byte, error) { |
| type NoMethod HttpRule |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // JwtLocation: Specifies a location to extract JWT from an API request. |
| type JwtLocation struct { |
| // Header: Specifies HTTP header name to extract JWT token. |
| Header string `json:"header,omitempty"` |
| |
| // Query: Specifies URL query parameter name to extract JWT token. |
| Query string `json:"query,omitempty"` |
| |
| // ValuePrefix: The value prefix. The value format is |
| // "value_prefix{token}" Only applies to "in" header type. Must be empty |
| // for "in" query type. If not empty, the header value has to match |
| // (case sensitive) this prefix. If not matched, JWT will not be |
| // extracted. If matched, JWT will be extracted after the prefix is |
| // removed. For example, for "Authorization: Bearer {JWT}", |
| // value_prefix="Bearer " with a space at the end. |
| ValuePrefix string `json:"valuePrefix,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Header") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Header") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *JwtLocation) MarshalJSON() ([]byte, error) { |
| type NoMethod JwtLocation |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // LabelDescriptor: A description of a label. |
| type LabelDescriptor struct { |
| // Description: A human-readable description for the label. |
| Description string `json:"description,omitempty"` |
| |
| // Key: The label key. |
| Key string `json:"key,omitempty"` |
| |
| // ValueType: The type of data that can be assigned to the label. |
| // |
| // Possible values: |
| // "STRING" - A variable-length string. This is the default. |
| // "BOOL" - Boolean; true or false. |
| // "INT64" - A 64-bit signed integer. |
| ValueType string `json:"valueType,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Description") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Description") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *LabelDescriptor) MarshalJSON() ([]byte, error) { |
| type NoMethod LabelDescriptor |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ListOperationsResponse: The response message for |
| // Operations.ListOperations. |
| type ListOperationsResponse struct { |
| // NextPageToken: The standard List next-page token. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| |
| // Operations: A list of operations that matches the specified filter in |
| // the request. |
| Operations []*Operation `json:"operations,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "NextPageToken") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "NextPageToken") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListOperationsResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod ListOperationsResponse |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ListServiceConfigsResponse: Response message for ListServiceConfigs |
| // method. |
| type ListServiceConfigsResponse struct { |
| // NextPageToken: The token of the next page of results. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| |
| // ServiceConfigs: The list of service configuration resources. |
| ServiceConfigs []*Service `json:"serviceConfigs,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "NextPageToken") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "NextPageToken") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListServiceConfigsResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod ListServiceConfigsResponse |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ListServiceRolloutsResponse: Response message for ListServiceRollouts |
| // method. |
| type ListServiceRolloutsResponse struct { |
| // NextPageToken: The token of the next page of results. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| |
| // Rollouts: The list of rollout resources. |
| Rollouts []*Rollout `json:"rollouts,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "NextPageToken") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "NextPageToken") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListServiceRolloutsResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod ListServiceRolloutsResponse |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ListServicesResponse: Response message for `ListServices` method. |
| type ListServicesResponse struct { |
| // NextPageToken: Token that can be passed to `ListServices` to resume a |
| // paginated query. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| |
| // Services: The returned services will only have the name field set. |
| Services []*ManagedService `json:"services,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "NextPageToken") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "NextPageToken") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListServicesResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod ListServicesResponse |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // LogDescriptor: A description of a log type. Example in YAML format: - |
| // name: library.googleapis.com/activity_history description: The |
| // history of borrowing and returning library items. display_name: |
| // Activity labels: - key: /customer_id description: Identifier of a |
| // library customer |
| type LogDescriptor struct { |
| // Description: A human-readable description of this log. This |
| // information appears in the documentation and can contain details. |
| Description string `json:"description,omitempty"` |
| |
| // DisplayName: The human-readable name for this log. This information |
| // appears on the user interface and should be concise. |
| DisplayName string `json:"displayName,omitempty"` |
| |
| // Labels: The set of labels that are available to describe a specific |
| // log entry. Runtime requests that contain labels not specified here |
| // are considered invalid. |
| Labels []*LabelDescriptor `json:"labels,omitempty"` |
| |
| // Name: The name of the log. It must be less than 512 characters long |
| // and can include the following characters: upper- and lower-case |
| // alphanumeric characters [A-Za-z0-9], and punctuation characters |
| // including slash, underscore, hyphen, period [/_-.]. |
| Name string `json:"name,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Description") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Description") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *LogDescriptor) MarshalJSON() ([]byte, error) { |
| type NoMethod LogDescriptor |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Logging: Logging configuration of the service. The following example |
| // shows how to configure logs to be sent to the producer and consumer |
| // projects. In the example, the `activity_history` log is sent to both |
| // the producer and consumer projects, whereas the `purchase_history` |
| // log is only sent to the producer project. monitored_resources: - |
| // type: library.googleapis.com/branch labels: - key: /city description: |
| // The city where the library branch is located in. - key: /name |
| // description: The name of the branch. logs: - name: activity_history |
| // labels: - key: /customer_id - name: purchase_history logging: |
| // producer_destinations: - monitored_resource: |
| // library.googleapis.com/branch logs: - activity_history - |
| // purchase_history consumer_destinations: - monitored_resource: |
| // library.googleapis.com/branch logs: - activity_history |
| type Logging struct { |
| // ConsumerDestinations: Logging configurations for sending logs to the |
| // consumer project. There can be multiple consumer destinations, each |
| // one must have a different monitored resource type. A log can be used |
| // in at most one consumer destination. |
| ConsumerDestinations []*LoggingDestination `json:"consumerDestinations,omitempty"` |
| |
| // ProducerDestinations: Logging configurations for sending logs to the |
| // producer project. There can be multiple producer destinations, each |
| // one must have a different monitored resource type. A log can be used |
| // in at most one producer destination. |
| ProducerDestinations []*LoggingDestination `json:"producerDestinations,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. |
| // "ConsumerDestinations") to unconditionally include in API requests. |
| // By default, fields with empty values are omitted from API requests. |
| // However, any non-pointer, non-interface field appearing in |
| // ForceSendFields will be sent to the server regardless of whether the |
| // field is empty or not. This may be used to include empty fields in |
| // Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "ConsumerDestinations") to |
| // include in API requests with the JSON null value. By default, fields |
| // with empty values are omitted from API requests. However, any field |
| // with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Logging) MarshalJSON() ([]byte, error) { |
| type NoMethod Logging |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // LoggingDestination: Configuration of a specific logging destination |
| // (the producer project or the consumer project). |
| type LoggingDestination struct { |
| // Logs: Names of the logs to be sent to this destination. Each name |
| // must be defined in the Service.logs section. If the log name is not a |
| // domain scoped name, it will be automatically prefixed with the |
| // service name followed by "/". |
| Logs []string `json:"logs,omitempty"` |
| |
| // MonitoredResource: The monitored resource type. The type must be |
| // defined in the Service.monitored_resources section. |
| MonitoredResource string `json:"monitoredResource,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Logs") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Logs") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *LoggingDestination) MarshalJSON() ([]byte, error) { |
| type NoMethod LoggingDestination |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // ManagedService: The full representation of a Service that is managed |
| // by Google Service Management. |
| type ManagedService struct { |
| // ProducerProjectId: ID of the project that produces and owns this |
| // service. |
| ProducerProjectId string `json:"producerProjectId,omitempty"` |
| |
| // ServiceName: The name of the service. See the |
| // [overview](/service-management/overview) for naming requirements. |
| ServiceName string `json:"serviceName,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the |
| // server. |
| googleapi.ServerResponse `json:"-"` |
| |
| // ForceSendFields is a list of field names (e.g. "ProducerProjectId") |
| // to unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "ProducerProjectId") to |
| // include in API requests with the JSON null value. By default, fields |
| // with empty values are omitted from API requests. However, any field |
| // with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ManagedService) MarshalJSON() ([]byte, error) { |
| type NoMethod ManagedService |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Method: Method represents a method of an API interface. |
| type Method struct { |
| // Name: The simple name of this method. |
| Name string `json:"name,omitempty"` |
| |
| // Options: Any metadata attached to the method. |
| Options []*Option `json:"options,omitempty"` |
| |
| // RequestStreaming: If true, the request is streamed. |
| RequestStreaming bool `json:"requestStreaming,omitempty"` |
| |
| // RequestTypeUrl: A URL of the input message type. |
| RequestTypeUrl string `json:"requestTypeUrl,omitempty"` |
| |
| // ResponseStreaming: If true, the response is streamed. |
| ResponseStreaming bool `json:"responseStreaming,omitempty"` |
| |
| // ResponseTypeUrl: The URL of the output message type. |
| ResponseTypeUrl string `json:"responseTypeUrl,omitempty"` |
| |
| // Syntax: The source syntax of this method. |
| // |
| // Possible values: |
| // "SYNTAX_PROTO2" - Syntax `proto2`. |
| // "SYNTAX_PROTO3" - Syntax `proto3`. |
| Syntax string `json:"syntax,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Name") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Name") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Method) MarshalJSON() ([]byte, error) { |
| type NoMethod Method |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // MetricDescriptor: Defines a metric type and its schema. Once a metric |
| // descriptor is created, deleting or altering it stops data collection |
| // and makes the metric type's existing data unusable. |
| type MetricDescriptor struct { |
| // Description: A detailed description of the metric, which can be used |
| // in documentation. |
| Description string `json:"description,omitempty"` |
| |
| // DisplayName: A concise name for the metric, which can be displayed in |
| // user interfaces. Use sentence case without an ending period, for |
| // example "Request count". This field is optional but it is recommended |
| // to be set for any metrics associated with user-visible concepts, such |
| // as Quota. |
| DisplayName string `json:"displayName,omitempty"` |
| |
| // Labels: The set of labels that can be used to describe a specific |
| // instance of this metric type. For example, the |
| // `appengine.googleapis.com/http/server/response_latencies` metric type |
| // has a label for the HTTP response code, `response_code`, so you can |
| // look at latencies for successful responses or just for responses that |
| // failed. |
| Labels []*LabelDescriptor `json:"labels,omitempty"` |
| |
| // LaunchStage: Optional. The launch stage of the metric definition. |
| // |
| // Possible values: |
| // "LAUNCH_STAGE_UNSPECIFIED" - Do not use this default value. |
| // "UNIMPLEMENTED" - The feature is not yet implemented. Users can not |
| // use it. |
| // "PRELAUNCH" - Prelaunch features are hidden from users and are only |
| // visible internally. |
| // "EARLY_ACCESS" - Early Access features are limited to a closed |
| // group of testers. To use these features, you must sign up in advance |
| // and sign a Trusted Tester agreement (which includes confidentiality |
| // provisions). These features may be unstable, changed in |
| // backward-incompatible ways, and are not guaranteed to be released. |
| // "ALPHA" - Alpha is a limited availability test for releases before |
| // they are cleared for widespread use. By Alpha, all significant design |
| // issues are resolved and we are in the process of verifying |
| // functionality. Alpha customers need to apply for access, agree to |
| // applicable terms, and have their projects whitelisted. Alpha releases |
| // don’t have to be feature complete, no SLAs are provided, and there |
| // are no technical support obligations, but they will be far enough |
| // along that customers can actually use them in test environments or |
| // for limited-use tests -- just like they would in normal production |
| // cases. |
| // "BETA" - Beta is the point at which we are ready to open a release |
| // for any customer to use. There are no SLA or technical support |
| // obligations in a Beta release. Products will be complete from a |
| // feature perspective, but may have some open outstanding issues. Beta |
| // releases are suitable for limited production use cases. |
| // "GA" - GA features are open to all developers and are considered |
| // stable and fully qualified for production use. |
| // "DEPRECATED" - Deprecated features are scheduled to be shut down |
| // and removed. For more information, see the “Deprecation Policy” |
| // section of our [Terms of Service](https://cloud.google.com/terms/) |
| // and the [Google Cloud Platform Subject to the Deprecation |
| // Policy](https://cloud.google.com/terms/deprecation) documentation. |
| LaunchStage string `json:"launchStage,omitempty"` |
| |
| // Metadata: Optional. Metadata which can be used to guide usage of the |
| // metric. |
| Metadata *MetricDescriptorMetadata `json:"metadata,omitempty"` |
| |
| // MetricKind: Whether the metric records instantaneous values, changes |
| // to a value, etc. Some combinations of `metric_kind` and `value_type` |
| // might not be supported. |
| // |
| // Possible values: |
| // "METRIC_KIND_UNSPECIFIED" - Do not use this default value. |
| // "GAUGE" - An instantaneous measurement of a value. |
| // "DELTA" - The change in a value during a time interval. |
| // "CUMULATIVE" - A value accumulated over a time interval. Cumulative |
| // measurements in a time series should have the same start time and |
| // increasing end times, until an event resets the cumulative value to |
| // zero and sets a new start time for the following points. |
| MetricKind string `json:"metricKind,omitempty"` |
| |
| // MonitoredResourceTypes: Read-only. If present, then a time series, |
| // which is identified partially by a metric type and a |
| // MonitoredResourceDescriptor, that is associated with this metric type |
| // can only be associated with one of the monitored resource types |
| // listed here. |
| MonitoredResourceTypes []string `json:"monitoredResourceTypes,omitempty"` |
| |
| // Name: The resource name of the metric descriptor. |
| Name string `json:"name,omitempty"` |
| |
| // Type: The metric type, including its DNS name prefix. The type is not |
| // URL-encoded. All user-defined metric types have the DNS name |
| // `custom.googleapis.com` or `external.googleapis.com`. Metric types |
| // should use a natural hierarchical grouping. For example: |
| // "custom.googleapis.com/invoice/paid/amount" |
| // "external.googleapis.com/prometheus/up" |
| // "appengine.googleapis.com/http/server/response_latencies" |
| Type string `json:"type,omitempty"` |
| |
| // Unit: The units in which the metric value is reported. It is only |
| // applicable if the `value_type` is `INT64`, `DOUBLE`, or |
| // `DISTRIBUTION`. The `unit` defines the representation of the stored |
| // metric values. Different systems may scale the values to be more |
| // easily displayed (so a value of `0.02KBy` _might_ be displayed as |
| // `20By`, and a value of `3523KBy` _might_ be displayed as `3.5MBy`). |
| // However, if the `unit` is `KBy`, then the value of the metric is |
| // always in thousands of bytes, no matter how it may be displayed.. If |
| // you want a custom metric to record the exact number of CPU-seconds |
| // used by a job, you can create an `INT64 CUMULATIVE` metric whose |
| // `unit` is `s{CPU}` (or equivalently `1s{CPU}` or just `s`). If the |
| // job uses 12,005 CPU-seconds, then the value is written as `12005`. |
| // Alternatively, if you want a custom metric to record data in a more |
| // granular way, you can create a `DOUBLE CUMULATIVE` metric whose |
| // `unit` is `ks{CPU}`, and then write the value `12.005` (which is |
| // `12005/1000`), or use `Kis{CPU}` and write `11.723` (which is |
| // `12005/1024`). The supported units are a subset of [The Unified Code |
| // for Units of Measure](http://unitsofmeasure.org/ucum.html) standard: |
| // **Basic units (UNIT)** * `bit` bit * `By` byte * `s` second * `min` |
| // minute * `h` hour * `d` day * `1` dimensionless **Prefixes (PREFIX)** |
| // * `k` kilo (10^3) * `M` mega (10^6) * `G` giga (10^9) * `T` tera |
| // (10^12) * `P` peta (10^15) * `E` exa (10^18) * `Z` zetta (10^21) * |
| // `Y` yotta (10^24) * `m` milli (10^-3) * `u` micro (10^-6) * `n` nano |
| // (10^-9) * `p` pico (10^-12) * `f` femto (10^-15) * `a` atto (10^-18) |
| // * `z` zepto (10^-21) * `y` yocto (10^-24) * `Ki` kibi (2^10) * `Mi` |
| // mebi (2^20) * `Gi` gibi (2^30) * `Ti` tebi (2^40) * `Pi` pebi (2^50) |
| // **Grammar** The grammar also includes these connectors: * `/` |
| // division or ratio (as an infix operator). For examples, `kBy/{email}` |
| // or `MiBy/10ms` (although you should almost never have `/s` in a |
| // metric `unit`; rates should always be computed at query time from the |
| // underlying cumulative or delta value). * `.` multiplication or |
| // composition (as an infix operator). For examples, `GBy.d` or |
| // `k{watt}.h`. The grammar for a unit is as follows: Expression = |
| // Component { "." Component } { "/" Component } ; Component = ( [ |
| // PREFIX ] UNIT | "%" ) [ Annotation ] | Annotation | "1" ; Annotation |
| // = "{" NAME "}" ; Notes: * `Annotation` is just a comment if it |
| // follows a `UNIT`. If the annotation is used alone, then the unit is |
| // equivalent to `1`. For examples, `{request}/s == 1/s`, |
| // `By{transmitted}/s == By/s`. * `NAME` is a sequence of non-blank |
| // printable ASCII characters not containing `{` or `}`. * `1` |
| // represents a unitary [dimensionless |
| // unit](https://en.wikipedia.org/wiki/Dimensionless_quantity) of 1, |
| // such as in `1/s`. It is typically used when none of the basic units |
| // are appropriate. For example, "new users per day" can be represented |
| // as `1/d` or `{new-users}/d` (and a metric value `5` would mean "5 new |
| // users). Alternatively, "thousands of page views per day" would be |
| // represented as `1000/d` or `k1/d` or `k{page_views}/d` (and a metric |
| // value of `5.3` would mean "5300 page views per day"). * `%` |
| // represents dimensionless value of 1/100, and annotates values giving |
| // a percentage (so the metric values are typically in the range of |
| // 0..100, and a metric value `3` means "3 percent"). * `10^2.%` |
| // indicates a metric contains a ratio, typically in the range 0..1, |
| // that will be multiplied by 100 and displayed as a percentage (so a |
| // metric value `0.03` means "3 percent"). |
| Unit string `json:"unit,omitempty"` |
| |
| // ValueType: Whether the measurement is an integer, a floating-point |
| // number, etc. Some combinations of `metric_kind` and `value_type` |
| // might not be supported. |
| // |
| // Possible values: |
| // "VALUE_TYPE_UNSPECIFIED" - Do not use this default value. |
| // "BOOL" - The value is a boolean. This value type can be used only |
| // if the metric kind is `GAUGE`. |
| // "INT64" - The value is a signed 64-bit integer. |
| // "DOUBLE" - The value is a double precision floating point number. |
| // "STRING" - The value is a text string. This value type can be used |
| // only if the metric kind is `GAUGE`. |
| // "DISTRIBUTION" - The value is a `Distribution`. |
| // "MONEY" - The value is money. |
| ValueType string `json:"valueType,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Description") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Description") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *MetricDescriptor) MarshalJSON() ([]byte, error) { |
| type NoMethod MetricDescriptor |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // MetricDescriptorMetadata: Additional annotations that can be used to |
| // guide the usage of a metric. |
| type MetricDescriptorMetadata struct { |
| // IngestDelay: The delay of data points caused by ingestion. Data |
| // points older than this age are guaranteed to be ingested and |
| // available to be read, excluding data loss due to errors. |
| IngestDelay string `json:"ingestDelay,omitempty"` |
| |
| // LaunchStage: Deprecated. Must use the MetricDescriptor.launch_stage |
| // instead. |
| // |
| // Possible values: |
| // "LAUNCH_STAGE_UNSPECIFIED" - Do not use this default value. |
| // "UNIMPLEMENTED" - The feature is not yet implemented. Users can not |
| // use it. |
| // "PRELAUNCH" - Prelaunch features are hidden from users and are only |
| // visible internally. |
| // "EARLY_ACCESS" - Early Access features are limited to a closed |
| // group of testers. To use these features, you must sign up in advance |
| // and sign a Trusted Tester agreement (which includes confidentiality |
| // provisions). These features may be unstable, changed in |
| // backward-incompatible ways, and are not guaranteed to be released. |
| // "ALPHA" - Alpha is a limited availability test for releases before |
| // they are cleared for widespread use. By Alpha, all significant design |
| // issues are resolved and we are in the process of verifying |
| // functionality. Alpha customers need to apply for access, agree to |
| // applicable terms, and have their projects whitelisted. Alpha releases |
| // don’t have to be feature complete, no SLAs are provided, and there |
| // are no technical support obligations, but they will be far enough |
| // along that customers can actually use them in test environments or |
| // for limited-use tests -- just like they would in normal production |
| // cases. |
| // "BETA" - Beta is the point at which we are ready to open a release |
| // for any customer to use. There are no SLA or technical support |
| // obligations in a Beta release. Products will be complete from a |
| // feature perspective, but may have some open outstanding issues. Beta |
| // releases are suitable for limited production use cases. |
| // "GA" - GA features are open to all developers and are considered |
| // stable and fully qualified for production use. |
| // "DEPRECATED" - Deprecated features are scheduled to be shut down |
| // and removed. For more information, see the “Deprecation Policy” |
| // section of our [Terms of Service](https://cloud.google.com/terms/) |
| // and the [Google Cloud Platform Subject to the Deprecation |
| // Policy](https://cloud.google.com/terms/deprecation) documentation. |
| LaunchStage string `json:"launchStage,omitempty"` |
| |
| // SamplePeriod: The sampling period of metric data points. For metrics |
| // which are written periodically, consecutive data points are stored at |
| // this time interval, excluding data loss due to errors. Metrics with a |
| // higher granularity have a smaller sampling period. |
| SamplePeriod string `json:"samplePeriod,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "IngestDelay") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "IngestDelay") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *MetricDescriptorMetadata) MarshalJSON() ([]byte, error) { |
| type NoMethod MetricDescriptorMetadata |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // MetricRule: Bind API methods to metrics. Binding a method to a metric |
| // causes that metric's configured quota behaviors to apply to the |
| // method call. |
| type MetricRule struct { |
| // MetricCosts: Metrics to update when the selected methods are called, |
| // and the associated cost applied to each metric. The key of the map is |
| // the metric name, and the values are the amount increased for the |
| // metric against which the quota limits are defined. The value must not |
| // be negative. |
| MetricCosts map[string]string `json:"metricCosts,omitempty"` |
| |
| // Selector: Selects the methods to which this rule applies. Refer to |
| // selector for syntax details. |
| Selector string `json:"selector,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "MetricCosts") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "MetricCosts") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *MetricRule) MarshalJSON() ([]byte, error) { |
| type NoMethod MetricRule |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Mixin: Declares an API Interface to be included in this interface. |
| // The including interface must redeclare all the methods from the |
| // included interface, but documentation and options are inherited as |
| // follows: - If after comment and whitespace stripping, the |
| // documentation string of the redeclared method is empty, it will be |
| // inherited from the original method. - Each annotation belonging to |
| // the service config (http, visibility) which is not set in the |
| // redeclared method will be inherited. - If an http annotation is |
| // inherited, the path pattern will be modified as follows. Any version |
| // prefix will be replaced by the version of the including interface |
| // plus the root path if specified. Example of a simple mixin: package |
| // google.acl.v1; service AccessControl { // Get the underlying ACL |
| // object. rpc GetAcl(GetAclRequest) returns (Acl) { option |
| // (google.api.http).get = "/v1/{resource=**}:getAcl"; } } package |
| // google.storage.v2; service Storage { // rpc GetAcl(GetAclRequest) |
| // returns (Acl); // Get a data record. rpc GetData(GetDataRequest) |
| // returns (Data) { option (google.api.http).get = "/v2/{resource=**}"; |
| // } } Example of a mixin configuration: apis: - name: |
| // google.storage.v2.Storage mixins: - name: google.acl.v1.AccessControl |
| // The mixin construct implies that all methods in `AccessControl` are |
| // also declared with same name and request/response types in `Storage`. |
| // A documentation generator or annotation processor will see the |
| // effective `Storage.GetAcl` method after inheriting documentation and |
| // annotations as follows: service Storage { // Get the underlying ACL |
| // object. rpc GetAcl(GetAclRequest) returns (Acl) { option |
| // (google.api.http).get = "/v2/{resource=**}:getAcl"; } ... } Note how |
| // the version in the path pattern changed from `v1` to `v2`. If the |
| // `root` field in the mixin is specified, it should be a relative path |
| // under which inherited HTTP paths are placed. Example: apis: - name: |
| // google.storage.v2.Storage mixins: - name: google.acl.v1.AccessControl |
| // root: acls This implies the following inherited HTTP annotation: |
| // service Storage { // Get the underlying ACL object. rpc |
| // GetAcl(GetAclRequest) returns (Acl) { option (google.api.http).get = |
| // "/v2/acls/{resource=**}:getAcl"; } ... } |
| type Mixin struct { |
| // Name: The fully qualified name of the interface which is included. |
| Name string `json:"name,omitempty"` |
| |
| // Root: If non-empty specifies a path under which inherited HTTP paths |
| // are rooted. |
| Root string `json:"root,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Name") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Name") to include in API |
| // requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Mixin) MarshalJSON() ([]byte, error) { |
| type NoMethod Mixin |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // MonitoredResourceDescriptor: An object that describes the schema of a |
| // MonitoredResource object using a type name and a set of labels. For |
| // example, the monitored resource descriptor for Google Compute Engine |
| // VM instances has a type of "gce_instance" and specifies the use of |
| // the labels "instance_id" and "zone" to identify particular VM |
| // instances. Different APIs can support different monitored resource |
| // types. APIs generally provide a `list` method that returns the |
| // monitored resource descriptors used by the API. |
| type MonitoredResourceDescriptor struct { |
| // Description: Optional. A detailed description of the monitored |
| // resource type that might be used in documentation. |
| Description string `json:"description,omitempty"` |
| |
| // DisplayName: Optional. A concise name for the monitored resource type |
| // that might be displayed in user interfaces. It should be a Title |
| // Cased Noun Phrase, without any article or other determiners. For |
| // example, "Google Cloud SQL Database". |
| DisplayName string `json:"displayName,omitempty"` |
| |
| // Labels: Required. A set of labels used to describe instances of this |
| // monitored resource type. For example, an individual Google Cloud SQL |
| // database is identified by values for the labels "database_id" and |
| // "zone". |
| Labels []*LabelDescriptor `json:"labels,omitempty"` |
| |
| // LaunchStage: Optional. The launch stage of the monitored resource |
| // definition. |
| // |
| // Possible values: |
| // "LAUNCH_STAGE_UNSPECIFIED" - Do not use this default value. |
| // "UNIMPLEMENTED" - The feature is not yet implemented. Users can not |
| // use it. |
| // "PRELAUNCH" - Prelaunch features are hidden from users and are only |
| // visible internally. |
| // "EARLY_ACCESS" - Early Access features are limited to a closed |
| // group of testers. To use these features, you must sign up in advance |
| // and sign a Trusted Tester agreement (which includes confidentiality |
| // provisions). These features may be unstable, changed in |
| // backward-incompatible ways, and are not guaranteed to be released. |
| // "ALPHA" - Alpha is a limited availability test for releases before |
| // they are cleared for widespread use. By Alpha, all significant design |
| // issues are resolved and we are in the process of verifying |
| // functionality. Alpha customers need to apply for access, agree to |
| // applicable terms, and have their projects whitelisted. Alpha releases |
| // don’t have to be feature complete, no SLAs are provided, and there |
| // are no technical support obligations, but they will be far enough |
| // along that customers can actually use them in test environments or |
| // for limited-use tests -- just like they would in normal production |
| // cases. |
| // "BETA" - Beta is the point at which we are ready to open a release |
| // for any customer to use. There are no SLA or technical support |
| // obligations in a Beta release. Products will be complete from a |
| // feature perspective, but may have some open outstanding issues. Beta |
| // releases are suitable for limited production use cases. |
| // "GA" - GA features are open to all developers and are considered |
| // stable and fully qualified for production use. |
| // "DEPRECATED" - Deprecated features are scheduled to be shut down |
| // and removed. For more information, see the “Deprecation Policy” |
| // section of our [Terms of Service](https://cloud.google.com/terms/) |
| // and the [Google Cloud Platform Subject to the Deprecation |
| // Policy](https://cloud.google.com/terms/deprecation) documentation. |
| LaunchStage string `json:"launchStage,omitempty"` |
| |
| // Name: Optional. The resource name of the monitored resource |
| // descriptor: |
| // "projects/{project_id}/monitoredResourceDescriptors/{type}" where |
| // {type} is the value of the `type` field in this object and |
| // {project_id} is a project ID that provides API-specific context for |
| // accessing the type. APIs that do not use project information can use |
| // the resource name format "monitoredResourceDescriptors/{type}". |
| Name string `json:"name,omitempty"` |
| |
| // Type: Required. The monitored resource type. For example, the type |
| // "cloudsql_database" represents databases in Google Cloud SQL. |
| Type string `json:"type,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Description") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Description") to include |
| // in API requests with the JSON null value. By default, fields with |
| // empty values are omitted from API requests. However, any field with |
| // an empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *MonitoredResourceDescriptor) MarshalJSON() ([]byte, error) { |
| type NoMethod MonitoredResourceDescriptor |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Monitoring: Monitoring configuration of the service. The example |
| // below shows how to configure monitored resources and metrics for |
| // monitoring. In the example, a monitored resource and two metrics are |
| // defined. The `library.googleapis.com/book/returned_count` metric is |
| // sent to both producer and consumer projects, whereas the |
| // `library.googleapis.com/book/num_overdue` metric is only sent to the |
| // consumer project. monitored_resources: - type: |
| // library.googleapis.com/Branch display_name: "Library Branch" |
| // description: "A branch of a library." launch_stage: GA labels: - key: |
| // resource_container description: "The Cloud container (ie. project id) |
| // for the Branch." - key: location description: "The location of the |
| // library branch." - key: branch_id description: "The id of the |
| // branch." metrics: - name: library.googleapis.com/book/returned_count |
| // display_name: "Books Returned" description: "The count of books that |
| // have been returned." launch_stage: GA metric_kind: DELTA value_type: |
| // INT64 unit: "1" labels: - key: customer_id description: "The id of |
| // the customer." - name: library.googleapis.com/book/num_overdue |
| // display_name: "Books Overdue" description: "The current number of |
| // overdue books." launch_stage: GA metric_kind: GAUGE value_type: INT64 |
| // unit: "1" labels: - key: customer_id description: "The id of the |
| // customer." monitoring: producer_destinations: - monitored_resource: |
| // library.googleapis.com/Branch metrics: - |
| // library.googleapis.com/book/returned_count consumer_destinations: - |
| // monitored_resource: library.googleapis.com/Branch metrics: - |
| // library.googleapis.com/book/returned_count - |
| // library.googleapis.com/book/num_overdue |
| type Monitoring struct { |
| // ConsumerDestinations: Monitoring configurations for sending metrics |
| // to the consumer project. There can be multiple consumer destinations. |
| // A monitored resource type may appear in multiple monitoring |
| // destinations if different aggregations are needed for different sets |
| // of metrics associated with that monitored resource type. A monitored |
| // resource and metric pair may only be used once in the Monitoring |
| // configuration. |
| ConsumerDestinations []*MonitoringDestination `json:"consumerDestinations,omitempty"` |
| |
| // ProducerDestinations: Monitoring configurations for sending metrics |
| // to the producer project. There can be multiple producer destinations. |
| // A monitored resource type may appear in multiple monitoring |
| // destinations if different aggregations are needed for different sets |
| // of metrics associated with that monitored resource type. A monitored |
| // resource and metric pair may only be used once in the Monitoring |
| // configuration. |
| ProducerDestinations []*MonitoringDestination `json:"producerDestinations,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. |
| // "ConsumerDestinations") to unconditionally include in API requests. |
| // By default, fields with empty values are omitted from API requests. |
| // However, any non-pointer, non-interface field appearing in |
| // ForceSendFields will be sent to the server regardless of whether the |
| // field is empty or not. This may be used to include empty fields in |
| // Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "ConsumerDestinations") to |
| // include in API requests with the JSON null value. By default, fields |
| // with empty values are omitted from API requests. However, any field |
| // with an empty value appearing in NullFields will be sent to the |
| // server as null. It is an error if a field in this list has a |
| // non-empty value. This may be used to include null fields in Patch |
| // requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Monitoring) MarshalJSON() ([]byte, error) { |
| type NoMethod Monitoring |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // MonitoringDestination: Configuration of a specific monitoring |
| // destination (the producer project or the consumer project). |
| type MonitoringDestination struct { |
| // Metrics: Types of the metrics to report to this monitoring |
| // destination. Each type must be defined in Service.metrics section. |
| Metrics []string `json:"metrics,omitempty"` |
| |
| // MonitoredResource: The monitored resource type. The type must be |
| // defined in Service.monitored_resources section. |
| MonitoredResource string `json:"monitoredResource,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Metrics") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "Metrics") to include in |
| // API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. However, any field with an |
| // empty value appearing in NullFields will be sent to the server as |
| // null. It is an error if a field in this list has a non-empty value. |
| // This may be used to include null fields in Patch requests. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *MonitoringDestination) MarshalJSON() ([]byte, error) { |
| type NoMethod MonitoringDestination |
| raw := NoMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // OAuthRequirements: OAuth scopes are a way to define data and |
| // permissions on data. For example, there are scopes defined for |
| // "Read-only access to Google Calendar" and "Access to Cloud Platform". |
| // Users can consent to a scope for an application, giving it permission |
| // to access that data on their behalf. OAuth scope specifications |
| // should be fairly coarse grained; a user will need to see and |
| // understand the text description of what your scope means. In most |
| // cases: use one or at most two OAuth scopes for an entire family of |
| // products. If your product has multiple APIs, you should probably be |
| // sharing the OAuth scope across all of those APIs. When you need finer |
| // grained OAuth consent screens: talk with your product management |
| // about how developers will use them in practice. Please note that even |
| // though each of the canonical scopes is enough for a request to be |
| // accepted and passed to the backend, a request can still fail due to |
| // the backend requiring additional scopes or permissions. |
| type OAuthRequirements struct { |
| // CanonicalScopes: The list of publicly documented OAuth scopes that |
| // are allowed access. An OAuth token containing any of these scopes |
| // will be accepted. Example: canonical_scopes: |
| // https://www.googleapis.com/auth/calendar, |
| // https://www.googleapis.com/auth/calendar.read |
| CanonicalScopes string `json:"canonicalScopes,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "CanonicalScopes") to |
| // unconditionally include in API requests. By default, fields with |
| // empty values are omitted from API requests. However, any non-pointer, |
| // non-interface field appearing in ForceSendFields will be sent to the |
| // server regardless of whether the field is empty or not. This may be |
| // used to include empty fields in Patch requests. |
| ForceSendFields []string `json:"-"` |
| |
| // NullFields is a list of field names (e.g. "CanonicalScopes") to |
| // include in API requests with the JSON null value. By default, fields |
| // with empty values are omitted from API requests. However, any field |
| // with an empty value appearing in NullFields will be se
|