| // Package servicemanagement provides access to the Google Service Management API. |
| // |
| // See https://cloud.google.com/service-management/ |
| // |
| // Usage example: |
| // |
| // import "google.golang.org/api/servicemanagement/v1" |
| // ... |
| // servicemanagementService, err := servicemanagement.New(oauthHttpClient) |
| package servicemanagement // import "google.golang.org/api/servicemanagement/v1" |
| |
| import ( |
| "bytes" |
| "encoding/json" |
| "errors" |
| "fmt" |
| context "golang.org/x/net/context" |
| ctxhttp "golang.org/x/net/context/ctxhttp" |
| gensupport "google.golang.org/api/gensupport" |
| googleapi "google.golang.org/api/googleapi" |
| "io" |
| "net/http" |
| "net/url" |
| "strconv" |
| "strings" |
| ) |
| |
| // 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 _ = ctxhttp.Do |
| |
| const apiId = "servicemanagement:v1" |
| const apiName = "servicemanagement" |
| const apiVersion = "v1" |
| const basePath = "https://servicemanagement.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" |
| ) |
| |
| 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<major-version>`, 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 |
| // AuditConfig are exempted. |
| // |
| // Example Policy with multiple AuditConfigs: |
| // |
| // { |
| // "audit_configs": [ |
| // { |
| // "service": "allServices" |
| // "audit_log_configs": [ |
| // { |
| // "log_type": "DATA_READ", |
| // "exempted_members": [ |
| // "user:foo@gmail.com" |
| // ] |
| // }, |
| // { |
| // "log_type": "DATA_WRITE", |
| // }, |
| // { |
| // "log_type": "ADMIN_READ", |
| // } |
| // ] |
| // }, |
| // { |
| // "service": "fooservice.googleapis.com" |
| // "audit_log_configs": [ |
| // { |
| // "log_type": "DATA_READ", |
| // }, |
| // { |
| // "log_type": "DATA_WRITE", |
| // "exempted_members": [ |
| // "user:bar@gmail.com" |
| // ] |
| // } |
| // ] |
| // } |
| // ] |
| // } |
| // |
| // For fooservice, this policy enables DATA_READ, DATA_WRITE and |
| // ADMIN_READ |
| // logging. It also exempts foo@gmail.com from DATA_READ logging, |
| // and |
| // bar@gmail.com from DATA_WRITE logging. |
| type AuditConfig struct { |
| // AuditLogConfigs: The configuration for logging of each type of |
| // permission. |
| // Next ID: 4 |
| AuditLogConfigs []*AuditLogConfig `json:"auditLogConfigs,omitempty"` |
| |
| ExemptedMembers []string `json:"exemptedMembers,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:foo@gmail.com" |
| // ] |
| // }, |
| // { |
| // "log_type": "DATA_WRITE", |
| // } |
| // ] |
| // } |
| // |
| // This enables 'DATA_READ' and 'DATA_WRITE' logging, while |
| // exempting |
| // foo@gmail.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 anthentication 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- |
| // token-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.librar |
| // y.v1.LibraryService". |
| // |
| // 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 no |
| // 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#sec |
| // tion-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"` |
| |
| // 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- |
| // token-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.librar |
| // y.v1.LibraryService". |
| // |
| // 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: Whether to allow requests without a |
| // credential. The credential can be |
| // an OAuth token, Google cookies (first-party auth) or |
| // EndUserCreds. |
| // |
| // For requests without credentials, if the service control environment |
| // is |
| // specified, each incoming request **must** be associated with a |
| // service |
| // consumer. This can be done by passing an API key that belongs to a |
| // consumer |
| // project. |
| AllowWithoutCredential bool `json:"allowWithoutCredential,omitempty"` |
| |
| // CustomAuth: Configuration for custom authentication. |
| CustomAuth *CustomAuthRequirements `json:"customAuth,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) |
| } |
| |
| // AuthorizationConfig: Configuration of authorization. |
| // |
| // This section determines the authorization provider, if unspecified, |
| // then no |
| // authorization check will be done. |
| // |
| // Example: |
| // |
| // experimental: |
| // authorization: |
| // provider: firebaserules.googleapis.com |
| type AuthorizationConfig struct { |
| // Provider: The name of the authorization provider, such |
| // as |
| // firebaserules.googleapis.com. |
| Provider string `json:"provider,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Provider") 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. "Provider") 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 *AuthorizationConfig) MarshalJSON() ([]byte, error) { |
| type noMethod AuthorizationConfig |
| 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. |
| Address string `json:"address,omitempty"` |
| |
| // Deadline: The number of seconds to wait for a response from a |
| // request. The default |
| // deadline for gRPC is infinite (no deadline) and HTTP requests is 5 |
| // seconds. |
| Deadline float64 `json:"deadline,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"` |
| |
| // 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"` |
| *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) |
| return nil |
| } |
| |
| // Billing: Billing related configuration of the service. |
| // |
| // The following example shows how to configure monitored resources and |
| // metrics |
| // for billing: |
| // |
| // 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. |
| // metrics: |
| // - name: library.googleapis.com/book/borrowed_count |
| // metric_kind: DELTA |
| // value_type: INT64 |
| // billing: |
| // consumer_destinations: |
| // - monitored_resource: library.googleapis.com/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. |
| // NOTE: an unsatisfied condition will not allow user access via |
| // current |
| // binding. Different bindings, including their conditions, are |
| // examined |
| // independently. |
| // This field is GOOGLE_INTERNAL. |
| 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@gmail.com` or `joe@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`. |
| // |
| // |
| // * `domain:{domain}`: A Google Apps domain name 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`. |
| // Required |
| 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.CreateBook"].restric |
| // tion |
| // - |
| // 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`. |
| 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 { |
| // 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. "Provided") 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. "Provided") 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) |
| } |
| |
| // CustomAuthRequirements: Configuration for a custom authentication |
| // provider. |
| type CustomAuthRequirements struct { |
| // Provider: A configuration string containing connection information |
| // for the |
| // authentication provider, typically formatted as a SmartService |
| // string |
| // (go/smartservice). |
| Provider string `json:"provider,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Provider") 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. "Provider") 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 *CustomAuthRequirements) MarshalJSON() ([]byte, error) { |
| type noMethod CustomAuthRequirements |
| 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) |
| } |
| |
| // DisableServiceRequest: Request message for DisableService method. |
| type DisableServiceRequest struct { |
| // ConsumerId: The identity of consumer resource which service |
| // disablement will be |
| // applied to. |
| // |
| // The Google Service Management implementation accepts the |
| // following |
| // forms: |
| // - "project:<project_id>" |
| // |
| // 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 *DisableServiceRequest) MarshalJSON() ([]byte, error) { |
| type noMethod DisableServiceRequest |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Documentation: `Documentation` provides the information for |
| // describing a service. |
| // |
| // Example: |
| // <pre><code>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: > |
| // ... |
| // </code></pre> |
| // 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: |
| // <pre><code>[fully.qualified.proto.name][]</code></pre> |
| // T |
| // o override the display text used for the link, this can be |
| // used: |
| // <pre><code>[display |
| // text][fully.qualified.proto.name]</code></pre> |
| // Text can be excluded from doc using the following |
| // notation: |
| // <pre><code>(-- internal comment --)</code></pre> |
| // Comments can be made conditional using a visibility label. The |
| // below |
| // text will be only rendered if the `BETA` label is |
| // available: |
| // <pre><code>(--BETA: comment for BETA users --)</code></pre> |
| // 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: |
| // <pre><code>(== include path/to/file ==)</code></pre> |
| // 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: |
| // <pre><code>(== resource_for v1.shelves.books |
| // ==)</code></pre> |
| // 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: |
| // <pre><code>documentation: |
| // summary: ... |
| // overview: (== include overview.md ==) |
| // </code></pre> |
| // This is a shortcut for the following declaration (using pages |
| // style): |
| // <pre><code>documentation: |
| // summary: ... |
| // pages: |
| // - name: Overview |
| // content: (== include overview.md ==) |
| // </code></pre> |
| // 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"` |
| |
| // 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". |
| // 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: The identity of consumer resource which service |
| // enablement will be |
| // applied to. |
| // |
| // The Google Service Management implementation accepts the |
| // following |
| // forms: |
| // - "project:<project_id>" |
| // |
| // 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) |
| } |
| |
| // 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_sh |
| // aring), 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"` |
| |
| // Apis: The list of APIs served by this endpoint. |
| // |
| // If no APIs are specified this translates to "all APIs" exported by |
| // the |
| // service, as defined in the top-level service configuration. |
| Apis []string `json:"apis,omitempty"` |
| |
| // Features: The list of features enabled on this endpoint. |
| Features []string `json:"features,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) |
| } |
| |
| // Experimental: Experimental service configuration. These configuration |
| // options can |
| // only be used by whitelisted users. |
| type Experimental struct { |
| // Authorization: Authorization configuration. |
| Authorization *AuthorizationConfig `json:"authorization,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "Authorization") 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. "Authorization") 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 *Experimental) MarshalJSON() ([]byte, error) { |
| type noMethod Experimental |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // Expr: Represents an expression text. Example: |
| // |
| // title: "User account presence" |
| // description: "Determines whether the request has a user account" |
| // expression: "size(request.user) > 0" |
| type Expr struct { |
| // Description: An 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. |
| // |
| // The application context of the containing message determines |
| // which |
| // well-known feature set of CEL is supported. |
| Expression string `json:"expression,omitempty"` |
| |
| // Location: An 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: An 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) |
| } |
| |
| // FlowOperationMetadata: The metadata associated with a long running |
| // operation resource. |
| type FlowOperationMetadata struct { |
| // CancelState: The state of the operation with respect to cancellation. |
| // |
| // Possible values: |
| // "RUNNING" - Default state, cancellable but not cancelled. |
| // "UNCANCELLABLE" - The operation has proceeded past the point of no |
| // return and cannot |
| // be cancelled. |
| // "CANCELLED" - The operation has been cancelled, work should |
| // cease |
| // and any needed rollback steps executed. |
| CancelState string `json:"cancelState,omitempty"` |
| |
| // Deadline: Deadline for the flow to complete, to prevent orphaned |
| // Operations. |
| // |
| // If the flow has not completed by this time, it may be terminated |
| // by |
| // the engine, or force-failed by Operation lookup. |
| // |
| // Note that this is not a hard deadline after which the Flow |
| // will |
| // definitely be failed, rather it is a deadline after which it is |
| // reasonable |
| // to suspect a problem and other parts of the system may kill |
| // operation |
| // to ensure we don't have orphans. |
| // see also: go/prevent-orphaned-operations |
| Deadline string `json:"deadline,omitempty"` |
| |
| // FlowName: The name of the top-level flow corresponding to this |
| // operation. |
| // Must be equal to the "name" field for a FlowName enum. |
| FlowName string `json:"flowName,omitempty"` |
| |
| // OperationType: Operation type which is a flow type and subtype info |
| // as that is missing in |
| // our datastore otherwise. This maps to the ordinal value of the |
| // enum: |
| // jcg/api/tenant/operations/OperationNamespace.java |
| OperationType int64 `json:"operationType,omitempty"` |
| |
| // ResourceNames: The full name of the resources that this flow is |
| // directly associated with. |
| ResourceNames []string `json:"resourceNames,omitempty"` |
| |
| // StartTime: The start time of the operation. |
| StartTime string `json:"startTime,omitempty"` |
| |
| // Possible values: |
| // "UNSPECIFIED_OP_SERVICE" |
| // "SERVICE_MANAGEMENT" |
| // "SERVICE_USAGE" |
| // "SERVICE_CONSUMER_MANAGEMENT" - TenancyUnit, ServiceNetworking fall |
| // under this |
| Surface string `json:"surface,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. "CancelState") 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. "CancelState") 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 *FlowOperationMetadata) MarshalJSON() ([]byte, error) { |
| type noMethod FlowOperationMetadata |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // GenerateConfigReportRequest: Request message for GenerateConfigReport |
| // method. |
| type GenerateConfigReportRequest struct { |
| // NewConfig: 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.servicemanag |
| // ement.v1.ConfigSource, |
| // and google.api.Service |
| NewConfig googleapi.RawMessage `json:"newConfig,omitempty"` |
| |
| // OldConfig: 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.servicemanag |
| // ement.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 { |
| } |
| |
| // 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 parmeters |
| // 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: `HttpRule` defines the mapping of an RPC method to one or |
| // more HTTP |
| // REST API methods. The mapping specifies how different portions of the |
| // RPC |
| // request message are mapped to URL path, URL query parameters, |
| // and |
| // HTTP request body. The mapping is typically specified as |
| // an |
| // `google.api.http` annotation on the RPC method, |
| // see "google/api/annotations.proto" for details. |
| // |
| // The mapping consists of a field specifying the path template |
| // and |
| // method kind. The path template can refer to fields in the |
| // request |
| // message, as in the example below which describes a REST GET |
| // operation on a resource collection of messages: |
| // |
| // |
| // service Messaging { |
| // rpc GetMessage(GetMessageRequest) returns (Message) { |
| // option (google.api.http).get = |
| // "/v1/messages/{message_id}/{sub.subfield}"; |
| // } |
| // } |
| // message GetMessageRequest { |
| // message SubMessage { |
| // string subfield = 1; |
| // } |
| // string message_id = 1; // mapped to the URL |
| // SubMessage sub = 2; // `sub.subfield` is url-mapped |
| // } |
| // message Message { |
| // string text = 1; // content of the resource |
| // } |
| // |
| // The same http annotation can alternatively be expressed inside |
| // the |
| // `GRPC API Configuration` YAML file. |
| // |
| // http: |
| // rules: |
| // - selector: <proto_package_name>.Messaging.GetMessage |
| // get: /v1/messages/{message_id}/{sub.subfield} |
| // |
| // This definition enables an automatic, bidrectional mapping of |
| // HTTP |
| // JSON to RPC. Example: |
| // |
| // HTTP | RPC |
| // -----|----- |
| // `GET /v1/messages/123456/foo` | `GetMessage(message_id: "123456" |
| // sub: SubMessage(subfield: "foo"))` |
| // |
| // In general, not only fields but also field paths can be |
| // referenced |
| // from a path pattern. Fields mapped to the path pattern cannot |
| // be |
| // repeated and must have a primitive (non-message) type. |
| // |
| // Any fields in the request message which are not bound by the |
| // path |
| // pattern automatically become (optional) HTTP query |
| // parameters. Assume the following definition of the request |
| // message: |
| // |
| // |
| // 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 the URL |
| // int64 revision = 2; // becomes a parameter |
| // SubMessage sub = 3; // `sub.subfield` becomes a parameter |
| // } |
| // |
| // |
| // This enables a HTTP JSON to RPC mapping as below: |
| // |
| // HTTP | RPC |
| // -----|----- |
| // `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 HTTP parameters must have |
| // a |
| // primitive type or a repeated primitive type. Message types are |
| // not |
| // allowed. In the case of a repeated type, the parameter can |
| // be |
| // repeated in the URL, as in `...?param=A¶m=B`. |
| // |
| // For HTTP method kinds which 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) = { |
| // put: "/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 | RPC |
| // -----|----- |
| // `PUT /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) = { |
| // put: "/v1/messages/{message_id}" |
| // body: "*" |
| // }; |
| // } |
| // } |
| // message Message { |
| // string message_id = 1; |
| // string text = 2; |
| // } |
| // |
| // |
| // The following HTTP JSON to RPC mapping is enabled: |
| // |
| // HTTP | RPC |
| // -----|----- |
| // `PUT /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 |
| // of |
| // 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 | RPC |
| // -----|----- |
| // `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 |
| // |
| // The rules for mapping HTTP path, query parameters, and body fields |
| // to the request message are as follows: |
| // |
| // 1. The `body` field specifies either `*` or a field path, or is |
| // omitted. If omitted, it indicates there is no HTTP request |
| // body. |
| // 2. Leaf fields (recursive expansion of nested messages in the |
| // request) can be classified into three types: |
| // (a) Matched in the URL template. |
| // (b) Covered by body (if body is `*`, everything except (a) |
| // fields; |
| // else everything under the body field) |
| // (c) All other fields. |
| // 3. URL query parameters found in the HTTP request are mapped to (c) |
| // fields. |
| // 4. Any body sent with an HTTP request can contain only (b) |
| // fields. |
| // |
| // The syntax of the path template is as follows: |
| // |
| // Template = "/" Segments [ Verb ] ; |
| // Segments = Segment { "/" Segment } ; |
| // Segment = "*" | "**" | LITERAL | Variable ; |
| // Variable = "{" FieldPath [ "=" Segments ] "}" ; |
| // FieldPath = IDENT { "." IDENT } ; |
| // Verb = ":" LITERAL ; |
| // |
| // The syntax `*` matches a single path segment. The syntax `**` matches |
| // zero |
| // or more path segments, which must be the last part of the path except |
| // the |
| // `Verb`. The syntax `LITERAL` matches literal text in the path. |
| // |
| // 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=*}`. |
| // |
| // If a variable contains exactly one path segment, such as "{var}" |
| // or |
| // "{var=*}", when such a variable is expanded into a URL path, all |
| // characters |
| // except `[-_.~0-9a-zA-Z]` are percent-encoded. Such variables show up |
| // in the |
| // Discovery Document as `{var}`. |
| // |
| // If a variable contains one or more path segments, such as |
| // "{var=foo/*}" |
| // or "{var=**}", when such a variable is expanded into a URL path, |
| // all |
| // characters except `[-_.~/0-9a-zA-Z]` are percent-encoded. Such |
| // variables |
| // show up in the Discovery Document as `{+var}`. |
| // |
| // NOTE: While the single segment variable matches the semantics of |
| // [RFC 6570](https://tools.ietf.org/html/rfc6570) Section 3.2.2 |
| // Simple String Expansion, the multi segment variable **does not** |
| // match |
| // RFC 6570 Reserved Expansion. The reason is that the Reserved |
| // Expansion |
| // does not expand special characters like `?` and `#`, which would |
| // lead |
| // to invalid URLs. |
| // |
| // NOTE: the field paths in variables and in the `body` must not refer |
| // to |
| // repeated fields or map fields. |
| 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"` |
| |
| // Body: The name of the request field whose value is mapped to the HTTP |
| // body, or |
| // `*` for mapping all fields not captured by the path pattern to the |
| // HTTP |
| // body. NOTE: the referred field must not be a repeated field and must |
| // be |
| // present at the top-level of 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: Used for deleting a resource. |
| Delete string `json:"delete,omitempty"` |
| |
| // Get: Used for listing and getting information about resources. |
| Get string `json:"get,omitempty"` |
| |
| // MediaDownload: Use this only for Scotty Requests. Do not use this for |
| // bytestream methods. |
| // For media support, add instead [][google.bytestream.RestByteStream] |
| // as an |
| // API to your configuration. |
| MediaDownload *MediaDownload `json:"mediaDownload,omitempty"` |
| |
| // MediaUpload: Use this only for Scotty Requests. Do not use this for |
| // media support using |
| // Bytestream, add instead |
| // [][google.bytestream.RestByteStream] as an API to your |
| // configuration for Bytestream methods. |
| MediaUpload *MediaUpload `json:"mediaUpload,omitempty"` |
| |
| // Patch: Used for updating a resource. |
| Patch string `json:"patch,omitempty"` |
| |
| // Post: Used for creating a resource. |
| Post string `json:"post,omitempty"` |
| |
| // Put: Used for updating a resource. |
| Put string `json:"put,omitempty"` |
| |
| // ResponseBody: The name of the response field whose value is mapped to |
| // the HTTP body of |
| // response. Other response fields are ignored. This field is optional. |
| // When |
| // not set, the response message will be used as HTTP body of |
| // response. |
| // NOTE: the referred field must be not a repeated field and must be |
| // present |
| // at the top-level of response message type. |
| ResponseBody string `json:"responseBody,omitempty"` |
| |
| // Selector: Selects 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. "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) |
| } |
| |
| // 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) |
| } |
| |
| // MediaDownload: Defines the Media configuration for a service in case |
| // of a download. |
| // Use this only for Scotty Requests. Do not use this for media support |
| // using |
| // Bytestream, add instead [][google.bytestream.RestByteStream] as an |
| // API to |
| // your configuration for Bytestream methods. |
| type MediaDownload struct { |
| // CompleteNotification: A boolean that determines whether a |
| // notification for the completion of a |
| // download should be sent to the backend. |
| CompleteNotification bool `json:"completeNotification,omitempty"` |
| |
| // DownloadService: DO NOT USE FIELDS BELOW THIS LINE UNTIL THIS WARNING |
| // IS REMOVED. |
| // |
| // Specify name of the download service if one is used for download. |
| DownloadService string `json:"downloadService,omitempty"` |
| |
| // Dropzone: Name of the Scotty dropzone to use for the current API. |
| Dropzone string `json:"dropzone,omitempty"` |
| |
| // Enabled: Whether download is enabled. |
| Enabled bool `json:"enabled,omitempty"` |
| |
| // MaxDirectDownloadSize: Optional maximum acceptable size for direct |
| // download. |
| // The size is specified in bytes. |
| MaxDirectDownloadSize int64 `json:"maxDirectDownloadSize,omitempty,string"` |
| |
| // UseDirectDownload: A boolean that determines if direct download from |
| // ESF should be used for |
| // download of this media. |
| UseDirectDownload bool `json:"useDirectDownload,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. |
| // "CompleteNotification") 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. "CompleteNotification") 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 *MediaDownload) MarshalJSON() ([]byte, error) { |
| type noMethod MediaDownload |
| raw := noMethod(*s) |
| return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) |
| } |
| |
| // MediaUpload: Defines the Media configuration for a service in case of |
| // an upload. |
| // Use this only for Scotty Requests. Do not use this for media support |
| // using |
| // Bytestream, add instead [][google.bytestream.RestByteStream] as an |
| // API to |
| // your configuration for Bytestream methods. |
| type MediaUpload struct { |
| // CompleteNotification: A boolean that determines whether a |
| // notification for the completion of an |
| // upload should be sent to the backend. These notifications will not be |
| // seen |
| // by the client and will not consume quota. |
| CompleteNotification bool `json:"completeNotification,omitempty"` |
| |
| // Dropzone: Name of the Scotty dropzone to use for the current API. |
| Dropzone string `json:"dropzone,omitempty"` |
| |
| // Enabled: Whether upload is enabled. |
| Enabled bool `json:"enabled,omitempty"` |
| |
| // MaxSize: Optional maximum acceptable size for an upload. |
| // The size is specified in bytes. |
| MaxSize int64 `json:"maxSize,omitempty,string"` |
| |
| // MimeTypes: An array of mimetype patterns. Esf will only accept |
| // uploads that match one |
| // of the given patterns. |
| MimeTypes []string `json:"mimeTypes,omitempty"` |
| |
| // ProgressNotification: Whether to receive a notification for progress |
| // changes of media upload. |
| ProgressNotification bool `json:"progressNotification,omitempty"` |
| |
| // StartNotification: Whether to receive a notification on the start of |
| // media upload. |
| StartNotification bool `json:"startNotification,omitempty"` |
| |
| // UploadService: DO NOT USE FIELDS BELOW THIS LINE UNTIL THIS WARNING |
| // IS REMOVED. |
| // |
| // Specify name of the upload service if one is used for upload. |
| UploadService string `json:"uploadService,omitempty"` |
| |
| // ForceSendFields is a list of field names (e.g. |
| // "CompleteNotification") 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. "CompleteNotification") 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 *MediaUpload) MarshalJSON() ([]byte, error) { |
| type noMethod MediaUpload |
| 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"` |
| |
| // 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"` |
| |
| // 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 custom metric types have the DNS |
| // name |
| // `custom.googleapis.com`. Metric types should use a natural |
| // hierarchical |
| // grouping. For example: |
| // |
| // "custom.googleapis.com/invoice/paid/amount" |
| // "appengine.googleapis.com/http/server/response_latencies" |
| Type string `json:"type,omitempty"` |
| |
| // Unit: The unit in which the metric value is reported. It is only |
| // applicable |
| // if the `value_type` is `INT64`, `DOUBLE`, or `DISTRIBUTION`. |
| // 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 |
| // |
| // **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) |
| // |
| // **Grammar** |
| // |
| // The grammar includes the dimensionless unit `1`, such as `1/s`. |
| // |
| // The grammar also includes these connectors: |
| // |
| // * `/` division (as an infix operator, e.g. `1/s`). |
| // * `.` multiplication (as an infix operator, e.g. `GBy.d`) |
| // |
| // 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` and is |
| // equivalent to `1` if it is used alone. For examples, |
| // `{requests}/s == 1/s`, `By{transmitted}/s == By/s`. |
| // * `NAME` is a sequence of non-blank printable ASCII characters not |
| // containing '{' or '}'. |
| 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:"-"` |
| |