google-apis-cloudbilling-v1-0.21.0/0000755000175000017500000000000014413340637015462 5ustar raviravigoogle-apis-cloudbilling-v1-0.21.0/LICENSE.md0000644000175000017500000002636114413340637017076 0ustar raviravi Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. google-apis-cloudbilling-v1-0.21.0/google-apis-cloudbilling_v1.gemspec0000644000175000017500000000514114413340637024311 0ustar raviravi######################################################### # This file has been automatically generated by gem2tgz # ######################################################### # -*- encoding: utf-8 -*- # stub: google-apis-cloudbilling_v1 0.21.0 ruby lib Gem::Specification.new do |s| s.name = "google-apis-cloudbilling_v1".freeze s.version = "0.21.0" s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version= s.metadata = { "bug_tracker_uri" => "https://github.com/googleapis/google-api-ruby-client/issues", "changelog_uri" => "https://github.com/googleapis/google-api-ruby-client/tree/main/generated/google-apis-cloudbilling_v1/CHANGELOG.md", "documentation_uri" => "https://googleapis.dev/ruby/google-apis-cloudbilling_v1/v0.21.0", "source_code_uri" => "https://github.com/googleapis/google-api-ruby-client/tree/main/generated/google-apis-cloudbilling_v1" } if s.respond_to? :metadata= s.require_paths = ["lib".freeze] s.authors = ["Google LLC".freeze] s.date = "2022-10-21" s.description = "This is the simple REST client for Cloud Billing API V1. Simple REST clients are Ruby client libraries that provide access to Google services via their HTTP REST API endpoints. These libraries are generated and updated automatically based on the discovery documents published by the service, and they handle most concerns such as authentication, pagination, retry, timeouts, and logging. You can use this client to access the Cloud Billing API, but note that some services may provide a separate modern client that is easier to use.".freeze s.email = "googleapis-packages@google.com".freeze s.files = [".yardopts".freeze, "CHANGELOG.md".freeze, "LICENSE.md".freeze, "OVERVIEW.md".freeze, "lib/google-apis-cloudbilling_v1.rb".freeze, "lib/google/apis/cloudbilling_v1.rb".freeze, "lib/google/apis/cloudbilling_v1/classes.rb".freeze, "lib/google/apis/cloudbilling_v1/gem_version.rb".freeze, "lib/google/apis/cloudbilling_v1/representations.rb".freeze, "lib/google/apis/cloudbilling_v1/service.rb".freeze] s.homepage = "https://github.com/google/google-api-ruby-client".freeze s.licenses = ["Apache-2.0".freeze] s.required_ruby_version = Gem::Requirement.new(">= 2.5".freeze) s.rubygems_version = "3.3.15".freeze s.summary = "Simple REST client for Cloud Billing API V1".freeze if s.respond_to? :specification_version then s.specification_version = 4 end if s.respond_to? :add_runtime_dependency then s.add_runtime_dependency(%q.freeze, [">= 0.9.1", "< 2.a"]) else s.add_dependency(%q.freeze, [">= 0.9.1", "< 2.a"]) end end google-apis-cloudbilling-v1-0.21.0/lib/0000755000175000017500000000000014413340637016230 5ustar raviravigoogle-apis-cloudbilling-v1-0.21.0/lib/google/0000755000175000017500000000000014413340637017504 5ustar raviravigoogle-apis-cloudbilling-v1-0.21.0/lib/google/apis/0000755000175000017500000000000014413340637020440 5ustar raviravigoogle-apis-cloudbilling-v1-0.21.0/lib/google/apis/cloudbilling_v1.rb0000644000175000017500000000317114413340637024044 0ustar raviravi# Copyright 2020 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. require 'google/apis/cloudbilling_v1/service.rb' require 'google/apis/cloudbilling_v1/classes.rb' require 'google/apis/cloudbilling_v1/representations.rb' require 'google/apis/cloudbilling_v1/gem_version.rb' module Google module Apis # Cloud Billing API # # Allows developers to manage billing for their Google Cloud Platform projects # programmatically. # # @see https://cloud.google.com/billing/ module CloudbillingV1 # Version of the Cloud Billing API this client connects to. # This is NOT the gem version. VERSION = 'V1' # View and manage your Google Cloud Platform billing accounts AUTH_CLOUD_BILLING = 'https://www.googleapis.com/auth/cloud-billing' # View your Google Cloud Platform billing accounts AUTH_CLOUD_BILLING_READONLY = 'https://www.googleapis.com/auth/cloud-billing.readonly' # See, edit, configure, and delete your Google Cloud data and see the email address for your Google Account. AUTH_CLOUD_PLATFORM = 'https://www.googleapis.com/auth/cloud-platform' end end end google-apis-cloudbilling-v1-0.21.0/lib/google/apis/cloudbilling_v1/0000755000175000017500000000000014413340637023515 5ustar raviravigoogle-apis-cloudbilling-v1-0.21.0/lib/google/apis/cloudbilling_v1/classes.rb0000644000175000017500000013657414413340637025517 0ustar raviravi# Copyright 2020 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. require 'date' require 'google/apis/core/base_service' require 'google/apis/core/json_representation' require 'google/apis/core/hashable' require 'google/apis/errors' module Google module Apis module CloudbillingV1 # Represents the aggregation level and interval for pricing of a single SKU. class AggregationInfo include Google::Apis::Core::Hashable # The number of intervals to aggregate over. Example: If aggregation_level is " # DAILY" and aggregation_count is 14, aggregation will be over 14 days. # Corresponds to the JSON property `aggregationCount` # @return [Fixnum] attr_accessor :aggregation_count # # Corresponds to the JSON property `aggregationInterval` # @return [String] attr_accessor :aggregation_interval # # Corresponds to the JSON property `aggregationLevel` # @return [String] attr_accessor :aggregation_level def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @aggregation_count = args[:aggregation_count] if args.key?(:aggregation_count) @aggregation_interval = args[:aggregation_interval] if args.key?(:aggregation_interval) @aggregation_level = args[:aggregation_level] if args.key?(:aggregation_level) end end # Specifies the audit configuration for a service. The configuration determines # which permission types are logged, and what identities, if any, are exempted # from logging. An AuditConfig must have one or more AuditLogConfigs. If there # are AuditConfigs for both `allServices` and a specific service, the union of # the two AuditConfigs is used for that service: the log_types specified in each # AuditConfig are enabled, and the exempted_members in each AuditLogConfig are # exempted. Example Policy with multiple AuditConfigs: ` "audit_configs": [ ` " # service": "allServices", "audit_log_configs": [ ` "log_type": "DATA_READ", " # exempted_members": [ "user:jose@example.com" ] `, ` "log_type": "DATA_WRITE" `, # ` "log_type": "ADMIN_READ" ` ] `, ` "service": "sampleservice.googleapis.com", # "audit_log_configs": [ ` "log_type": "DATA_READ" `, ` "log_type": "DATA_WRITE" # , "exempted_members": [ "user:aliya@example.com" ] ` ] ` ] ` For sampleservice, # this policy enables DATA_READ, DATA_WRITE and ADMIN_READ logging. It also # exempts `jose@example.com` from DATA_READ logging, and `aliya@example.com` # from DATA_WRITE logging. class AuditConfig include Google::Apis::Core::Hashable # The configuration for logging of each type of permission. # Corresponds to the JSON property `auditLogConfigs` # @return [Array] attr_accessor :audit_log_configs # 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. # Corresponds to the JSON property `service` # @return [String] attr_accessor :service def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @audit_log_configs = args[:audit_log_configs] if args.key?(:audit_log_configs) @service = args[:service] if args.key?(:service) end end # Provides the configuration for logging a type of permissions. Example: ` " # audit_log_configs": [ ` "log_type": "DATA_READ", "exempted_members": [ "user: # jose@example.com" ] `, ` "log_type": "DATA_WRITE" ` ] ` This enables ' # DATA_READ' and 'DATA_WRITE' logging, while exempting jose@example.com from # DATA_READ logging. class AuditLogConfig include Google::Apis::Core::Hashable # Specifies the identities that do not cause logging for this type of permission. # Follows the same format of Binding.members. # Corresponds to the JSON property `exemptedMembers` # @return [Array] attr_accessor :exempted_members # The log type that this config enables. # Corresponds to the JSON property `logType` # @return [String] attr_accessor :log_type def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @exempted_members = args[:exempted_members] if args.key?(:exempted_members) @log_type = args[:log_type] if args.key?(:log_type) end end # A billing account in the [Google Cloud Console](https://console.cloud.google. # com/). You can assign a billing account to one or more projects. class BillingAccount include Google::Apis::Core::Hashable # The display name given to the billing account, such as `My Billing Account`. # This name is displayed in the Google Cloud Console. # Corresponds to the JSON property `displayName` # @return [String] attr_accessor :display_name # If this account is a [subaccount](https://cloud.google.com/billing/docs/ # concepts), then this will be the resource name of the parent billing account # that it is being resold through. Otherwise this will be empty. # Corresponds to the JSON property `masterBillingAccount` # @return [String] attr_accessor :master_billing_account # Output only. The resource name of the billing account. The resource name has # the form `billingAccounts/`billing_account_id``. For example, `billingAccounts/ # 012345-567890-ABCDEF` would be the resource name for billing account `012345- # 567890-ABCDEF`. # Corresponds to the JSON property `name` # @return [String] attr_accessor :name # Output only. True if the billing account is open, and will therefore be # charged for any usage on associated projects. False if the billing account is # closed, and therefore projects associated with it will be unable to use paid # services. # Corresponds to the JSON property `open` # @return [Boolean] attr_accessor :open alias_method :open?, :open def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @display_name = args[:display_name] if args.key?(:display_name) @master_billing_account = args[:master_billing_account] if args.key?(:master_billing_account) @name = args[:name] if args.key?(:name) @open = args[:open] if args.key?(:open) end end # Associates `members`, or principals, with a `role`. class Binding include Google::Apis::Core::Hashable # Represents a textual expression in the Common Expression Language (CEL) syntax. # CEL is a C-like expression language. The syntax and semantics of CEL are # documented at https://github.com/google/cel-spec. Example (Comparison): title: # "Summary size limit" description: "Determines if a summary is less than 100 # chars" expression: "document.summary.size() < 100" Example (Equality): title: " # Requestor is owner" description: "Determines if requestor is the document # owner" expression: "document.owner == request.auth.claims.email" Example ( # Logic): title: "Public documents" description: "Determine whether the document # should be publicly visible" expression: "document.type != 'private' && # document.type != 'internal'" Example (Data Manipulation): title: "Notification # string" description: "Create a notification string with a timestamp." # expression: "'New message received at ' + string(document.create_time)" The # exact variables and functions that may be referenced within an expression are # determined by the service that evaluates it. See the service documentation for # additional information. # Corresponds to the JSON property `condition` # @return [Google::Apis::CloudbillingV1::Expr] attr_accessor :condition # Specifies the principals requesting access for a Google Cloud 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. Does # not include identities that come from external identity providers (IdPs) # through identity federation. * `user:`emailid``: An email address that # represents a specific Google account. For example, `alice@example.com` . * ` # serviceAccount:`emailid``: An email address that represents a Google service # account. For example, `my-other-app@appspot.gserviceaccount.com`. * ` # serviceAccount:`projectid`.svc.id.goog[`namespace`/`kubernetes-sa`]`: An # identifier for a [Kubernetes service account](https://cloud.google.com/ # kubernetes-engine/docs/how-to/kubernetes-service-accounts). For example, `my- # project.svc.id.goog[my-namespace/my-kubernetes-sa]`. * `group:`emailid``: An # email address that represents a Google group. For example, `admins@example.com` # . * `deleted:user:`emailid`?uid=`uniqueid``: An email address (plus unique # identifier) representing a user that has been recently deleted. For example, ` # alice@example.com?uid=123456789012345678901`. If the user is recovered, this # value reverts to `user:`emailid`` and the recovered user retains the role in # the binding. * `deleted:serviceAccount:`emailid`?uid=`uniqueid``: An email # address (plus unique identifier) representing a service account that has been # recently deleted. For example, `my-other-app@appspot.gserviceaccount.com?uid= # 123456789012345678901`. If the service account is undeleted, this value # reverts to `serviceAccount:`emailid`` and the undeleted service account # retains the role in the binding. * `deleted:group:`emailid`?uid=`uniqueid``: # An email address (plus unique identifier) representing a Google group that has # been recently deleted. For example, `admins@example.com?uid= # 123456789012345678901`. If the group is recovered, this value reverts to ` # group:`emailid`` and the recovered group retains the role in the binding. * ` # domain:`domain``: The G Suite domain (primary) that represents all the users # of that domain. For example, `google.com` or `example.com`. # Corresponds to the JSON property `members` # @return [Array] attr_accessor :members # Role that is assigned to the list of `members`, or principals. For example, ` # roles/viewer`, `roles/editor`, or `roles/owner`. # Corresponds to the JSON property `role` # @return [String] attr_accessor :role def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @condition = args[:condition] if args.key?(:condition) @members = args[:members] if args.key?(:members) @role = args[:role] if args.key?(:role) end end # Represents the category hierarchy of a SKU. class Category include Google::Apis::Core::Hashable # The type of product the SKU refers to. Example: "Compute", "Storage", "Network" # , "ApplicationServices" etc. # Corresponds to the JSON property `resourceFamily` # @return [String] attr_accessor :resource_family # A group classification for related SKUs. Example: "RAM", "GPU", "Prediction", " # Ops", "GoogleEgress" etc. # Corresponds to the JSON property `resourceGroup` # @return [String] attr_accessor :resource_group # The display name of the service this SKU belongs to. # Corresponds to the JSON property `serviceDisplayName` # @return [String] attr_accessor :service_display_name # Represents how the SKU is consumed. Example: "OnDemand", "Preemptible", " # Commit1Mo", "Commit1Yr" etc. # Corresponds to the JSON property `usageType` # @return [String] attr_accessor :usage_type def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @resource_family = args[:resource_family] if args.key?(:resource_family) @resource_group = args[:resource_group] if args.key?(:resource_group) @service_display_name = args[:service_display_name] if args.key?(:service_display_name) @usage_type = args[:usage_type] if args.key?(:usage_type) end end # Represents a textual expression in the Common Expression Language (CEL) syntax. # CEL is a C-like expression language. The syntax and semantics of CEL are # documented at https://github.com/google/cel-spec. Example (Comparison): title: # "Summary size limit" description: "Determines if a summary is less than 100 # chars" expression: "document.summary.size() < 100" Example (Equality): title: " # Requestor is owner" description: "Determines if requestor is the document # owner" expression: "document.owner == request.auth.claims.email" Example ( # Logic): title: "Public documents" description: "Determine whether the document # should be publicly visible" expression: "document.type != 'private' && # document.type != 'internal'" Example (Data Manipulation): title: "Notification # string" description: "Create a notification string with a timestamp." # expression: "'New message received at ' + string(document.create_time)" The # exact variables and functions that may be referenced within an expression are # determined by the service that evaluates it. See the service documentation for # additional information. class Expr include Google::Apis::Core::Hashable # Optional. Description of the expression. This is a longer text which describes # the expression, e.g. when hovered over it in a UI. # Corresponds to the JSON property `description` # @return [String] attr_accessor :description # Textual representation of an expression in Common Expression Language syntax. # Corresponds to the JSON property `expression` # @return [String] attr_accessor :expression # Optional. String indicating the location of the expression for error reporting, # e.g. a file name and a position in the file. # Corresponds to the JSON property `location` # @return [String] attr_accessor :location # 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. # Corresponds to the JSON property `title` # @return [String] attr_accessor :title def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @description = args[:description] if args.key?(:description) @expression = args[:expression] if args.key?(:expression) @location = args[:location] if args.key?(:location) @title = args[:title] if args.key?(:title) end end # Encapsulates the geographic taxonomy data for a sku. class GeoTaxonomy include Google::Apis::Core::Hashable # The list of regions associated with a sku. Empty for Global skus, which are # associated with all Google Cloud regions. # Corresponds to the JSON property `regions` # @return [Array] attr_accessor :regions # The type of Geo Taxonomy: GLOBAL, REGIONAL, or MULTI_REGIONAL. # Corresponds to the JSON property `type` # @return [String] attr_accessor :type def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @regions = args[:regions] if args.key?(:regions) @type = args[:type] if args.key?(:type) end end # Response message for `ListBillingAccounts`. class ListBillingAccountsResponse include Google::Apis::Core::Hashable # A list of billing accounts. # Corresponds to the JSON property `billingAccounts` # @return [Array] attr_accessor :billing_accounts # A token to retrieve the next page of results. To retrieve the next page, call ` # ListBillingAccounts` again with the `page_token` field set to this value. This # field is empty if there are no more results to retrieve. # Corresponds to the JSON property `nextPageToken` # @return [String] attr_accessor :next_page_token def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @billing_accounts = args[:billing_accounts] if args.key?(:billing_accounts) @next_page_token = args[:next_page_token] if args.key?(:next_page_token) end end # Request message for `ListProjectBillingInfoResponse`. class ListProjectBillingInfoResponse include Google::Apis::Core::Hashable # A token to retrieve the next page of results. To retrieve the next page, call ` # ListProjectBillingInfo` again with the `page_token` field set to this value. # This field is empty if there are no more results to retrieve. # Corresponds to the JSON property `nextPageToken` # @return [String] attr_accessor :next_page_token # A list of `ProjectBillingInfo` resources representing the projects associated # with the billing account. # Corresponds to the JSON property `projectBillingInfo` # @return [Array] attr_accessor :project_billing_info def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @next_page_token = args[:next_page_token] if args.key?(:next_page_token) @project_billing_info = args[:project_billing_info] if args.key?(:project_billing_info) end end # Response message for `ListServices`. class ListServicesResponse include Google::Apis::Core::Hashable # A token to retrieve the next page of results. To retrieve the next page, call ` # ListServices` again with the `page_token` field set to this value. This field # is empty if there are no more results to retrieve. # Corresponds to the JSON property `nextPageToken` # @return [String] attr_accessor :next_page_token # A list of services. # Corresponds to the JSON property `services` # @return [Array] attr_accessor :services def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @next_page_token = args[:next_page_token] if args.key?(:next_page_token) @services = args[:services] if args.key?(:services) end end # Response message for `ListSkus`. class ListSkusResponse include Google::Apis::Core::Hashable # A token to retrieve the next page of results. To retrieve the next page, call ` # ListSkus` again with the `page_token` field set to this value. This field is # empty if there are no more results to retrieve. # Corresponds to the JSON property `nextPageToken` # @return [String] attr_accessor :next_page_token # The list of public SKUs of the given service. # Corresponds to the JSON property `skus` # @return [Array] attr_accessor :skus def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @next_page_token = args[:next_page_token] if args.key?(:next_page_token) @skus = args[:skus] if args.key?(:skus) end end # Represents an amount of money with its currency type. class Money include Google::Apis::Core::Hashable # The three-letter currency code defined in ISO 4217. # Corresponds to the JSON property `currencyCode` # @return [String] attr_accessor :currency_code # Number of nano (10^-9) units of the amount. The value must be between -999,999, # 999 and +999,999,999 inclusive. If `units` is positive, `nanos` must be # positive or zero. If `units` is zero, `nanos` can be positive, zero, or # negative. If `units` is negative, `nanos` must be negative or zero. For # example $-1.75 is represented as `units`=-1 and `nanos`=-750,000,000. # Corresponds to the JSON property `nanos` # @return [Fixnum] attr_accessor :nanos # The whole units of the amount. For example if `currencyCode` is `"USD"`, then # 1 unit is one US dollar. # Corresponds to the JSON property `units` # @return [Fixnum] attr_accessor :units def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @currency_code = args[:currency_code] if args.key?(:currency_code) @nanos = args[:nanos] if args.key?(:nanos) @units = args[:units] if args.key?(:units) end end # An Identity and Access Management (IAM) policy, which specifies access # controls for Google Cloud resources. A `Policy` is a collection of `bindings`. # A `binding` binds one or more `members`, or principals, to a single `role`. # Principals can be user accounts, service accounts, Google groups, and domains ( # such as G Suite). A `role` is a named list of permissions; each `role` can be # an IAM predefined role or a user-created custom role. For some types of Google # Cloud resources, a `binding` can also specify a `condition`, which is a # logical expression that allows access to a resource only if the expression # evaluates to `true`. A condition can add constraints based on attributes of # the request, the resource, or both. To learn which resources support # conditions in their IAM policies, see the [IAM documentation](https://cloud. # google.com/iam/help/conditions/resource-policies). **JSON example:** ` " # bindings": [ ` "role": "roles/resourcemanager.organizationAdmin", "members": [ # "user:mike@example.com", "group:admins@example.com", "domain:google.com", " # serviceAccount:my-project-id@appspot.gserviceaccount.com" ] `, ` "role": " # roles/resourcemanager.organizationViewer", "members": [ "user:eve@example.com" # ], "condition": ` "title": "expirable access", "description": "Does not grant # access after Sep 2020", "expression": "request.time < timestamp('2020-10-01T00: # 00:00.000Z')", ` ` ], "etag": "BwWWja0YfJA=", "version": 3 ` **YAML example:** # bindings: - members: - user:mike@example.com - group:admins@example.com - # domain:google.com - serviceAccount:my-project-id@appspot.gserviceaccount.com # role: roles/resourcemanager.organizationAdmin - members: - user:eve@example. # com role: roles/resourcemanager.organizationViewer condition: title: expirable # access description: Does not grant access after Sep 2020 expression: request. # time < timestamp('2020-10-01T00:00:00.000Z') etag: BwWWja0YfJA= version: 3 For # a description of IAM and its features, see the [IAM documentation](https:// # cloud.google.com/iam/docs/). class Policy include Google::Apis::Core::Hashable # Specifies cloud audit logging configuration for this policy. # Corresponds to the JSON property `auditConfigs` # @return [Array] attr_accessor :audit_configs # Associates a list of `members`, or principals, with a `role`. Optionally, may # specify a `condition` that determines how and when the `bindings` are applied. # Each of the `bindings` must contain at least one principal. The `bindings` in # a `Policy` can refer to up to 1,500 principals; up to 250 of these principals # can be Google groups. Each occurrence of a principal counts towards these # limits. For example, if the `bindings` grant 50 different roles to `user:alice@ # example.com`, and not to any other principal, then you can add another 1,450 # principals to the `bindings` in the `Policy`. # Corresponds to the JSON property `bindings` # @return [Array] attr_accessor :bindings # `etag` is used for optimistic concurrency control as a way to help prevent # simultaneous updates of a policy from overwriting each other. It is strongly # suggested that systems make use of the `etag` in the read-modify-write cycle # to perform policy updates in order to avoid race conditions: An `etag` is # returned in the response to `getIamPolicy`, and systems are expected to put # that etag in the request to `setIamPolicy` to ensure that their change will be # applied to the same version of the policy. **Important:** If you use IAM # Conditions, you must include the `etag` field whenever you call `setIamPolicy`. # If you omit this field, then IAM allows you to overwrite a version `3` policy # with a version `1` policy, and all of the conditions in the version `3` policy # are lost. # Corresponds to the JSON property `etag` # NOTE: Values are automatically base64 encoded/decoded in the client library. # @return [String] attr_accessor :etag # Specifies the format of the policy. Valid values are `0`, `1`, and `3`. # Requests that specify an invalid value are rejected. Any operation that # affects conditional role bindings must specify version `3`. This requirement # applies to the following operations: * Getting a policy that includes a # conditional role binding * Adding a conditional role binding to a policy * # Changing a conditional role binding in a policy * Removing any role binding, # with or without a condition, from a policy that includes conditions ** # Important:** If you use IAM Conditions, you must include the `etag` field # whenever you call `setIamPolicy`. If you omit this field, then IAM allows you # to overwrite a version `3` policy with a version `1` policy, and all of the # conditions in the version `3` policy are lost. If a policy does not include # any conditions, operations on that policy may specify any valid version or # leave the field unset. To learn which resources support conditions in their # IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/ # conditions/resource-policies). # Corresponds to the JSON property `version` # @return [Fixnum] attr_accessor :version def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @audit_configs = args[:audit_configs] if args.key?(:audit_configs) @bindings = args[:bindings] if args.key?(:bindings) @etag = args[:etag] if args.key?(:etag) @version = args[:version] if args.key?(:version) end end # Expresses a mathematical pricing formula. For Example:- `usage_unit: GBy` ` # tiered_rates:` `[start_usage_amount: 20, unit_price: $10]` `[ # start_usage_amount: 100, unit_price: $5]` The above expresses a pricing # formula where the first 20GB is free, the next 80GB is priced at $10 per GB # followed by $5 per GB for additional usage. class PricingExpression include Google::Apis::Core::Hashable # The base unit for the SKU which is the unit used in usage exports. Example: " # By" # Corresponds to the JSON property `baseUnit` # @return [String] attr_accessor :base_unit # Conversion factor for converting from price per usage_unit to price per # base_unit, and start_usage_amount to start_usage_amount in base_unit. # unit_price / base_unit_conversion_factor = price per base_unit. # start_usage_amount * base_unit_conversion_factor = start_usage_amount in # base_unit. # Corresponds to the JSON property `baseUnitConversionFactor` # @return [Float] attr_accessor :base_unit_conversion_factor # The base unit in human readable form. Example: "byte". # Corresponds to the JSON property `baseUnitDescription` # @return [String] attr_accessor :base_unit_description # The recommended quantity of units for displaying pricing info. When displaying # pricing info it is recommended to display: (unit_price * display_quantity) per # display_quantity usage_unit. This field does not affect the pricing formula # and is for display purposes only. Example: If the unit_price is "0.0001 USD", # the usage_unit is "GB" and the display_quantity is "1000" then the recommended # way of displaying the pricing info is "0.10 USD per 1000 GB" # Corresponds to the JSON property `displayQuantity` # @return [Float] attr_accessor :display_quantity # The list of tiered rates for this pricing. The total cost is computed by # applying each of the tiered rates on usage. This repeated list is sorted by # ascending order of start_usage_amount. # Corresponds to the JSON property `tieredRates` # @return [Array] attr_accessor :tiered_rates # The short hand for unit of usage this pricing is specified in. Example: # usage_unit of "GiBy" means that usage is specified in "Gibi Byte". # Corresponds to the JSON property `usageUnit` # @return [String] attr_accessor :usage_unit # The unit of usage in human readable form. Example: "gibi byte". # Corresponds to the JSON property `usageUnitDescription` # @return [String] attr_accessor :usage_unit_description def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @base_unit = args[:base_unit] if args.key?(:base_unit) @base_unit_conversion_factor = args[:base_unit_conversion_factor] if args.key?(:base_unit_conversion_factor) @base_unit_description = args[:base_unit_description] if args.key?(:base_unit_description) @display_quantity = args[:display_quantity] if args.key?(:display_quantity) @tiered_rates = args[:tiered_rates] if args.key?(:tiered_rates) @usage_unit = args[:usage_unit] if args.key?(:usage_unit) @usage_unit_description = args[:usage_unit_description] if args.key?(:usage_unit_description) end end # Represents the pricing information for a SKU at a single point of time. class PricingInfo include Google::Apis::Core::Hashable # Represents the aggregation level and interval for pricing of a single SKU. # Corresponds to the JSON property `aggregationInfo` # @return [Google::Apis::CloudbillingV1::AggregationInfo] attr_accessor :aggregation_info # Conversion rate used for currency conversion, from USD to the currency # specified in the request. This includes any surcharge collected for billing in # non USD currency. If a currency is not specified in the request this defaults # to 1.0. Example: USD * currency_conversion_rate = JPY # Corresponds to the JSON property `currencyConversionRate` # @return [Float] attr_accessor :currency_conversion_rate # The timestamp from which this pricing was effective within the requested time # range. This is guaranteed to be greater than or equal to the start_time field # in the request and less than the end_time field in the request. If a time # range was not specified in the request this field will be equivalent to a time # within the last 12 hours, indicating the latest pricing info. # Corresponds to the JSON property `effectiveTime` # @return [String] attr_accessor :effective_time # Expresses a mathematical pricing formula. For Example:- `usage_unit: GBy` ` # tiered_rates:` `[start_usage_amount: 20, unit_price: $10]` `[ # start_usage_amount: 100, unit_price: $5]` The above expresses a pricing # formula where the first 20GB is free, the next 80GB is priced at $10 per GB # followed by $5 per GB for additional usage. # Corresponds to the JSON property `pricingExpression` # @return [Google::Apis::CloudbillingV1::PricingExpression] attr_accessor :pricing_expression # An optional human readable summary of the pricing information, has a maximum # length of 256 characters. # Corresponds to the JSON property `summary` # @return [String] attr_accessor :summary def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @aggregation_info = args[:aggregation_info] if args.key?(:aggregation_info) @currency_conversion_rate = args[:currency_conversion_rate] if args.key?(:currency_conversion_rate) @effective_time = args[:effective_time] if args.key?(:effective_time) @pricing_expression = args[:pricing_expression] if args.key?(:pricing_expression) @summary = args[:summary] if args.key?(:summary) end end # Encapsulation of billing information for a Google Cloud Console project. A # project has at most one associated billing account at a time (but a billing # account can be assigned to multiple projects). class ProjectBillingInfo include Google::Apis::Core::Hashable # The resource name of the billing account associated with the project, if any. # For example, `billingAccounts/012345-567890-ABCDEF`. # Corresponds to the JSON property `billingAccountName` # @return [String] attr_accessor :billing_account_name # True if the project is associated with an open billing account, to which usage # on the project is charged. False if the project is associated with a closed # billing account, or no billing account at all, and therefore cannot use paid # services. This field is read-only. # Corresponds to the JSON property `billingEnabled` # @return [Boolean] attr_accessor :billing_enabled alias_method :billing_enabled?, :billing_enabled # The resource name for the `ProjectBillingInfo`; has the form `projects/` # project_id`/billingInfo`. For example, the resource name for the billing # information for project `tokyo-rain-123` would be `projects/tokyo-rain-123/ # billingInfo`. This field is read-only. # Corresponds to the JSON property `name` # @return [String] attr_accessor :name # The ID of the project that this `ProjectBillingInfo` represents, such as ` # tokyo-rain-123`. This is a convenience field so that you don't need to parse # the `name` field to obtain a project ID. This field is read-only. # Corresponds to the JSON property `projectId` # @return [String] attr_accessor :project_id def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @billing_account_name = args[:billing_account_name] if args.key?(:billing_account_name) @billing_enabled = args[:billing_enabled] if args.key?(:billing_enabled) @name = args[:name] if args.key?(:name) @project_id = args[:project_id] if args.key?(:project_id) end end # Encapsulates a single service in Google Cloud Platform. class Service include Google::Apis::Core::Hashable # The business under which the service is offered. Ex. "businessEntities/GCP", " # businessEntities/Maps" # Corresponds to the JSON property `businessEntityName` # @return [String] attr_accessor :business_entity_name # A human readable display name for this service. # Corresponds to the JSON property `displayName` # @return [String] attr_accessor :display_name # The resource name for the service. Example: "services/DA34-426B-A397" # Corresponds to the JSON property `name` # @return [String] attr_accessor :name # The identifier for the service. Example: "DA34-426B-A397" # Corresponds to the JSON property `serviceId` # @return [String] attr_accessor :service_id def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @business_entity_name = args[:business_entity_name] if args.key?(:business_entity_name) @display_name = args[:display_name] if args.key?(:display_name) @name = args[:name] if args.key?(:name) @service_id = args[:service_id] if args.key?(:service_id) end end # Request message for `SetIamPolicy` method. class SetIamPolicyRequest include Google::Apis::Core::Hashable # An Identity and Access Management (IAM) policy, which specifies access # controls for Google Cloud resources. A `Policy` is a collection of `bindings`. # A `binding` binds one or more `members`, or principals, to a single `role`. # Principals can be user accounts, service accounts, Google groups, and domains ( # such as G Suite). A `role` is a named list of permissions; each `role` can be # an IAM predefined role or a user-created custom role. For some types of Google # Cloud resources, a `binding` can also specify a `condition`, which is a # logical expression that allows access to a resource only if the expression # evaluates to `true`. A condition can add constraints based on attributes of # the request, the resource, or both. To learn which resources support # conditions in their IAM policies, see the [IAM documentation](https://cloud. # google.com/iam/help/conditions/resource-policies). **JSON example:** ` " # bindings": [ ` "role": "roles/resourcemanager.organizationAdmin", "members": [ # "user:mike@example.com", "group:admins@example.com", "domain:google.com", " # serviceAccount:my-project-id@appspot.gserviceaccount.com" ] `, ` "role": " # roles/resourcemanager.organizationViewer", "members": [ "user:eve@example.com" # ], "condition": ` "title": "expirable access", "description": "Does not grant # access after Sep 2020", "expression": "request.time < timestamp('2020-10-01T00: # 00:00.000Z')", ` ` ], "etag": "BwWWja0YfJA=", "version": 3 ` **YAML example:** # bindings: - members: - user:mike@example.com - group:admins@example.com - # domain:google.com - serviceAccount:my-project-id@appspot.gserviceaccount.com # role: roles/resourcemanager.organizationAdmin - members: - user:eve@example. # com role: roles/resourcemanager.organizationViewer condition: title: expirable # access description: Does not grant access after Sep 2020 expression: request. # time < timestamp('2020-10-01T00:00:00.000Z') etag: BwWWja0YfJA= version: 3 For # a description of IAM and its features, see the [IAM documentation](https:// # cloud.google.com/iam/docs/). # Corresponds to the JSON property `policy` # @return [Google::Apis::CloudbillingV1::Policy] attr_accessor :policy # OPTIONAL: A FieldMask specifying which fields of the policy to modify. Only # the fields in the mask will be modified. If no mask is provided, the following # default mask is used: `paths: "bindings, etag"` # Corresponds to the JSON property `updateMask` # @return [String] attr_accessor :update_mask def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @policy = args[:policy] if args.key?(:policy) @update_mask = args[:update_mask] if args.key?(:update_mask) end end # Encapsulates a single SKU in Google Cloud Platform class Sku include Google::Apis::Core::Hashable # Represents the category hierarchy of a SKU. # Corresponds to the JSON property `category` # @return [Google::Apis::CloudbillingV1::Category] attr_accessor :category # A human readable description of the SKU, has a maximum length of 256 # characters. # Corresponds to the JSON property `description` # @return [String] attr_accessor :description # Encapsulates the geographic taxonomy data for a sku. # Corresponds to the JSON property `geoTaxonomy` # @return [Google::Apis::CloudbillingV1::GeoTaxonomy] attr_accessor :geo_taxonomy # The resource name for the SKU. Example: "services/DA34-426B-A397/skus/AA95- # CD31-42FE" # Corresponds to the JSON property `name` # @return [String] attr_accessor :name # A timeline of pricing info for this SKU in chronological order. # Corresponds to the JSON property `pricingInfo` # @return [Array] attr_accessor :pricing_info # Identifies the service provider. This is 'Google' for first party services in # Google Cloud Platform. # Corresponds to the JSON property `serviceProviderName` # @return [String] attr_accessor :service_provider_name # List of service regions this SKU is offered at. Example: "asia-east1" Service # regions can be found at https://cloud.google.com/about/locations/ # Corresponds to the JSON property `serviceRegions` # @return [Array] attr_accessor :service_regions # The identifier for the SKU. Example: "AA95-CD31-42FE" # Corresponds to the JSON property `skuId` # @return [String] attr_accessor :sku_id def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @category = args[:category] if args.key?(:category) @description = args[:description] if args.key?(:description) @geo_taxonomy = args[:geo_taxonomy] if args.key?(:geo_taxonomy) @name = args[:name] if args.key?(:name) @pricing_info = args[:pricing_info] if args.key?(:pricing_info) @service_provider_name = args[:service_provider_name] if args.key?(:service_provider_name) @service_regions = args[:service_regions] if args.key?(:service_regions) @sku_id = args[:sku_id] if args.key?(:sku_id) end end # Request message for `TestIamPermissions` method. class TestIamPermissionsRequest include Google::Apis::Core::Hashable # The set of permissions to check for the `resource`. Permissions with wildcards # (such as `*` or `storage.*`) are not allowed. For more information see [IAM # Overview](https://cloud.google.com/iam/docs/overview#permissions). # Corresponds to the JSON property `permissions` # @return [Array] attr_accessor :permissions def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @permissions = args[:permissions] if args.key?(:permissions) end end # Response message for `TestIamPermissions` method. class TestIamPermissionsResponse include Google::Apis::Core::Hashable # A subset of `TestPermissionsRequest.permissions` that the caller is allowed. # Corresponds to the JSON property `permissions` # @return [Array] attr_accessor :permissions def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @permissions = args[:permissions] if args.key?(:permissions) end end # The price rate indicating starting usage and its corresponding price. class TierRate include Google::Apis::Core::Hashable # Usage is priced at this rate only after this amount. Example: # start_usage_amount of 10 indicates that the usage will be priced at the # unit_price after the first 10 usage_units. # Corresponds to the JSON property `startUsageAmount` # @return [Float] attr_accessor :start_usage_amount # Represents an amount of money with its currency type. # Corresponds to the JSON property `unitPrice` # @return [Google::Apis::CloudbillingV1::Money] attr_accessor :unit_price def initialize(**args) update!(**args) end # Update properties of this object def update!(**args) @start_usage_amount = args[:start_usage_amount] if args.key?(:start_usage_amount) @unit_price = args[:unit_price] if args.key?(:unit_price) end end end end end google-apis-cloudbilling-v1-0.21.0/lib/google/apis/cloudbilling_v1/representations.rb0000644000175000017500000003353414413340637027277 0ustar raviravi# Copyright 2020 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. require 'date' require 'google/apis/core/base_service' require 'google/apis/core/json_representation' require 'google/apis/core/hashable' require 'google/apis/errors' module Google module Apis module CloudbillingV1 class AggregationInfo class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end class AuditConfig class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end class AuditLogConfig class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end class BillingAccount class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end class Binding class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end class Category class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end class Expr class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end class GeoTaxonomy class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end class ListBillingAccountsResponse class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end class ListProjectBillingInfoResponse class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end class ListServicesResponse class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end class ListSkusResponse class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end class Money class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end class Policy class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end class PricingExpression class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end class PricingInfo class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end class ProjectBillingInfo class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end class Service class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end class SetIamPolicyRequest class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end class Sku class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end class TestIamPermissionsRequest class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end class TestIamPermissionsResponse class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end class TierRate class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end class AggregationInfo # @private class Representation < Google::Apis::Core::JsonRepresentation property :aggregation_count, as: 'aggregationCount' property :aggregation_interval, as: 'aggregationInterval' property :aggregation_level, as: 'aggregationLevel' end end class AuditConfig # @private class Representation < Google::Apis::Core::JsonRepresentation collection :audit_log_configs, as: 'auditLogConfigs', class: Google::Apis::CloudbillingV1::AuditLogConfig, decorator: Google::Apis::CloudbillingV1::AuditLogConfig::Representation property :service, as: 'service' end end class AuditLogConfig # @private class Representation < Google::Apis::Core::JsonRepresentation collection :exempted_members, as: 'exemptedMembers' property :log_type, as: 'logType' end end class BillingAccount # @private class Representation < Google::Apis::Core::JsonRepresentation property :display_name, as: 'displayName' property :master_billing_account, as: 'masterBillingAccount' property :name, as: 'name' property :open, as: 'open' end end class Binding # @private class Representation < Google::Apis::Core::JsonRepresentation property :condition, as: 'condition', class: Google::Apis::CloudbillingV1::Expr, decorator: Google::Apis::CloudbillingV1::Expr::Representation collection :members, as: 'members' property :role, as: 'role' end end class Category # @private class Representation < Google::Apis::Core::JsonRepresentation property :resource_family, as: 'resourceFamily' property :resource_group, as: 'resourceGroup' property :service_display_name, as: 'serviceDisplayName' property :usage_type, as: 'usageType' end end class Expr # @private class Representation < Google::Apis::Core::JsonRepresentation property :description, as: 'description' property :expression, as: 'expression' property :location, as: 'location' property :title, as: 'title' end end class GeoTaxonomy # @private class Representation < Google::Apis::Core::JsonRepresentation collection :regions, as: 'regions' property :type, as: 'type' end end class ListBillingAccountsResponse # @private class Representation < Google::Apis::Core::JsonRepresentation collection :billing_accounts, as: 'billingAccounts', class: Google::Apis::CloudbillingV1::BillingAccount, decorator: Google::Apis::CloudbillingV1::BillingAccount::Representation property :next_page_token, as: 'nextPageToken' end end class ListProjectBillingInfoResponse # @private class Representation < Google::Apis::Core::JsonRepresentation property :next_page_token, as: 'nextPageToken' collection :project_billing_info, as: 'projectBillingInfo', class: Google::Apis::CloudbillingV1::ProjectBillingInfo, decorator: Google::Apis::CloudbillingV1::ProjectBillingInfo::Representation end end class ListServicesResponse # @private class Representation < Google::Apis::Core::JsonRepresentation property :next_page_token, as: 'nextPageToken' collection :services, as: 'services', class: Google::Apis::CloudbillingV1::Service, decorator: Google::Apis::CloudbillingV1::Service::Representation end end class ListSkusResponse # @private class Representation < Google::Apis::Core::JsonRepresentation property :next_page_token, as: 'nextPageToken' collection :skus, as: 'skus', class: Google::Apis::CloudbillingV1::Sku, decorator: Google::Apis::CloudbillingV1::Sku::Representation end end class Money # @private class Representation < Google::Apis::Core::JsonRepresentation property :currency_code, as: 'currencyCode' property :nanos, as: 'nanos' property :units, :numeric_string => true, as: 'units' end end class Policy # @private class Representation < Google::Apis::Core::JsonRepresentation collection :audit_configs, as: 'auditConfigs', class: Google::Apis::CloudbillingV1::AuditConfig, decorator: Google::Apis::CloudbillingV1::AuditConfig::Representation collection :bindings, as: 'bindings', class: Google::Apis::CloudbillingV1::Binding, decorator: Google::Apis::CloudbillingV1::Binding::Representation property :etag, :base64 => true, as: 'etag' property :version, as: 'version' end end class PricingExpression # @private class Representation < Google::Apis::Core::JsonRepresentation property :base_unit, as: 'baseUnit' property :base_unit_conversion_factor, as: 'baseUnitConversionFactor' property :base_unit_description, as: 'baseUnitDescription' property :display_quantity, as: 'displayQuantity' collection :tiered_rates, as: 'tieredRates', class: Google::Apis::CloudbillingV1::TierRate, decorator: Google::Apis::CloudbillingV1::TierRate::Representation property :usage_unit, as: 'usageUnit' property :usage_unit_description, as: 'usageUnitDescription' end end class PricingInfo # @private class Representation < Google::Apis::Core::JsonRepresentation property :aggregation_info, as: 'aggregationInfo', class: Google::Apis::CloudbillingV1::AggregationInfo, decorator: Google::Apis::CloudbillingV1::AggregationInfo::Representation property :currency_conversion_rate, as: 'currencyConversionRate' property :effective_time, as: 'effectiveTime' property :pricing_expression, as: 'pricingExpression', class: Google::Apis::CloudbillingV1::PricingExpression, decorator: Google::Apis::CloudbillingV1::PricingExpression::Representation property :summary, as: 'summary' end end class ProjectBillingInfo # @private class Representation < Google::Apis::Core::JsonRepresentation property :billing_account_name, as: 'billingAccountName' property :billing_enabled, as: 'billingEnabled' property :name, as: 'name' property :project_id, as: 'projectId' end end class Service # @private class Representation < Google::Apis::Core::JsonRepresentation property :business_entity_name, as: 'businessEntityName' property :display_name, as: 'displayName' property :name, as: 'name' property :service_id, as: 'serviceId' end end class SetIamPolicyRequest # @private class Representation < Google::Apis::Core::JsonRepresentation property :policy, as: 'policy', class: Google::Apis::CloudbillingV1::Policy, decorator: Google::Apis::CloudbillingV1::Policy::Representation property :update_mask, as: 'updateMask' end end class Sku # @private class Representation < Google::Apis::Core::JsonRepresentation property :category, as: 'category', class: Google::Apis::CloudbillingV1::Category, decorator: Google::Apis::CloudbillingV1::Category::Representation property :description, as: 'description' property :geo_taxonomy, as: 'geoTaxonomy', class: Google::Apis::CloudbillingV1::GeoTaxonomy, decorator: Google::Apis::CloudbillingV1::GeoTaxonomy::Representation property :name, as: 'name' collection :pricing_info, as: 'pricingInfo', class: Google::Apis::CloudbillingV1::PricingInfo, decorator: Google::Apis::CloudbillingV1::PricingInfo::Representation property :service_provider_name, as: 'serviceProviderName' collection :service_regions, as: 'serviceRegions' property :sku_id, as: 'skuId' end end class TestIamPermissionsRequest # @private class Representation < Google::Apis::Core::JsonRepresentation collection :permissions, as: 'permissions' end end class TestIamPermissionsResponse # @private class Representation < Google::Apis::Core::JsonRepresentation collection :permissions, as: 'permissions' end end class TierRate # @private class Representation < Google::Apis::Core::JsonRepresentation property :start_usage_amount, as: 'startUsageAmount' property :unit_price, as: 'unitPrice', class: Google::Apis::CloudbillingV1::Money, decorator: Google::Apis::CloudbillingV1::Money::Representation end end end end end google-apis-cloudbilling-v1-0.21.0/lib/google/apis/cloudbilling_v1/gem_version.rb0000644000175000017500000000165214413340637026363 0ustar raviravi# Copyright 2020 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. module Google module Apis module CloudbillingV1 # Version of the google-apis-cloudbilling_v1 gem GEM_VERSION = "0.21.0" # Version of the code generator used to generate this client GENERATOR_VERSION = "0.11.0" # Revision of the discovery document this client was generated from REVISION = "20220908" end end end google-apis-cloudbilling-v1-0.21.0/lib/google/apis/cloudbilling_v1/service.rb0000644000175000017500000010662114413340637025510 0ustar raviravi# Copyright 2020 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. require 'google/apis/core/base_service' require 'google/apis/core/json_representation' require 'google/apis/core/hashable' require 'google/apis/errors' module Google module Apis module CloudbillingV1 # Cloud Billing API # # Allows developers to manage billing for their Google Cloud Platform projects # programmatically. # # @example # require 'google/apis/cloudbilling_v1' # # Cloudbilling = Google::Apis::CloudbillingV1 # Alias the module # service = Cloudbilling::CloudbillingService.new # # @see https://cloud.google.com/billing/ class CloudbillingService < Google::Apis::Core::BaseService # @return [String] # API key. Your API key identifies your project and provides you with API access, # quota, and reports. Required unless you provide an OAuth 2.0 token. attr_accessor :key # @return [String] # Available to use for quota purposes for server-side applications. Can be any # arbitrary string assigned to a user, but should not exceed 40 characters. attr_accessor :quota_user def initialize super('https://cloudbilling.googleapis.com/', '', client_name: 'google-apis-cloudbilling_v1', client_version: Google::Apis::CloudbillingV1::GEM_VERSION) @batch_path = 'batch' end # This method creates [billing subaccounts](https://cloud.google.com/billing/ # docs/concepts#subaccounts). Google Cloud resellers should use the Channel # Services APIs, [accounts.customers.create](https://cloud.google.com/channel/ # docs/reference/rest/v1/accounts.customers/create) and [accounts.customers. # entitlements.create](https://cloud.google.com/channel/docs/reference/rest/v1/ # accounts.customers.entitlements/create). When creating a subaccount, the # current authenticated user must have the `billing.accounts.update` IAM # permission on the parent account, which is typically given to billing account [ # administrators](https://cloud.google.com/billing/docs/how-to/billing-access). # This method will return an error if the parent account has not been # provisioned as a reseller account. # @param [Google::Apis::CloudbillingV1::BillingAccount] billing_account_object # @param [String] fields # Selector specifying which fields to include in a partial response. # @param [String] quota_user # Available to use for quota purposes for server-side applications. Can be any # arbitrary string assigned to a user, but should not exceed 40 characters. # @param [Google::Apis::RequestOptions] options # Request-specific options # # @yield [result, err] Result & error if block supplied # @yieldparam result [Google::Apis::CloudbillingV1::BillingAccount] parsed result object # @yieldparam err [StandardError] error object if request failed # # @return [Google::Apis::CloudbillingV1::BillingAccount] # # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification # @raise [Google::Apis::AuthorizationError] Authorization is required def create_billing_account(billing_account_object = nil, fields: nil, quota_user: nil, options: nil, &block) command = make_simple_command(:post, 'v1/billingAccounts', options) command.request_representation = Google::Apis::CloudbillingV1::BillingAccount::Representation command.request_object = billing_account_object command.response_representation = Google::Apis::CloudbillingV1::BillingAccount::Representation command.response_class = Google::Apis::CloudbillingV1::BillingAccount command.query['fields'] = fields unless fields.nil? command.query['quotaUser'] = quota_user unless quota_user.nil? execute_or_queue_command(command, &block) end # Gets information about a billing account. The current authenticated user must # be a [viewer of the billing account](https://cloud.google.com/billing/docs/how- # to/billing-access). # @param [String] name # Required. The resource name of the billing account to retrieve. For example, ` # billingAccounts/012345-567890-ABCDEF`. # @param [String] fields # Selector specifying which fields to include in a partial response. # @param [String] quota_user # Available to use for quota purposes for server-side applications. Can be any # arbitrary string assigned to a user, but should not exceed 40 characters. # @param [Google::Apis::RequestOptions] options # Request-specific options # # @yield [result, err] Result & error if block supplied # @yieldparam result [Google::Apis::CloudbillingV1::BillingAccount] parsed result object # @yieldparam err [StandardError] error object if request failed # # @return [Google::Apis::CloudbillingV1::BillingAccount] # # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification # @raise [Google::Apis::AuthorizationError] Authorization is required def get_billing_account(name, fields: nil, quota_user: nil, options: nil, &block) command = make_simple_command(:get, 'v1/{+name}', options) command.response_representation = Google::Apis::CloudbillingV1::BillingAccount::Representation command.response_class = Google::Apis::CloudbillingV1::BillingAccount command.params['name'] = name unless name.nil? command.query['fields'] = fields unless fields.nil? command.query['quotaUser'] = quota_user unless quota_user.nil? execute_or_queue_command(command, &block) end # Gets the access control policy for a billing account. The caller must have the # `billing.accounts.getIamPolicy` permission on the account, which is often # given to billing account [viewers](https://cloud.google.com/billing/docs/how- # to/billing-access). # @param [String] resource # REQUIRED: The resource for which the policy is being requested. See [Resource # names](https://cloud.google.com/apis/design/resource_names) for the # appropriate value for this field. # @param [Fixnum] options_requested_policy_version # Optional. The maximum policy version that will be used to format the policy. # Valid values are 0, 1, and 3. Requests specifying an invalid value will be # rejected. Requests for policies with any conditional role bindings must # specify version 3. Policies with no conditional role bindings may specify any # valid value or leave the field unset. The policy in the response might use the # policy version that you specified, or it might use a lower policy version. For # example, if you specify version 3, but the policy has no conditional role # bindings, the response uses version 1. To learn which resources support # conditions in their IAM policies, see the [IAM documentation](https://cloud. # google.com/iam/help/conditions/resource-policies). # @param [String] fields # Selector specifying which fields to include in a partial response. # @param [String] quota_user # Available to use for quota purposes for server-side applications. Can be any # arbitrary string assigned to a user, but should not exceed 40 characters. # @param [Google::Apis::RequestOptions] options # Request-specific options # # @yield [result, err] Result & error if block supplied # @yieldparam result [Google::Apis::CloudbillingV1::Policy] parsed result object # @yieldparam err [StandardError] error object if request failed # # @return [Google::Apis::CloudbillingV1::Policy] # # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification # @raise [Google::Apis::AuthorizationError] Authorization is required def get_billing_account_iam_policy(resource, options_requested_policy_version: nil, fields: nil, quota_user: nil, options: nil, &block) command = make_simple_command(:get, 'v1/{+resource}:getIamPolicy', options) command.response_representation = Google::Apis::CloudbillingV1::Policy::Representation command.response_class = Google::Apis::CloudbillingV1::Policy command.params['resource'] = resource unless resource.nil? command.query['options.requestedPolicyVersion'] = options_requested_policy_version unless options_requested_policy_version.nil? command.query['fields'] = fields unless fields.nil? command.query['quotaUser'] = quota_user unless quota_user.nil? execute_or_queue_command(command, &block) end # Lists the billing accounts that the current authenticated user has permission # to [view](https://cloud.google.com/billing/docs/how-to/billing-access). # @param [String] filter # Options for how to filter the returned billing accounts. Currently this only # supports filtering for [subaccounts](https://cloud.google.com/billing/docs/ # concepts) under a single provided reseller billing account. (e.g. " # master_billing_account=billingAccounts/012345-678901-ABCDEF"). Boolean algebra # and other fields are not currently supported. # @param [Fixnum] page_size # Requested page size. The maximum page size is 100; this is also the default. # @param [String] page_token # A token identifying a page of results to return. This should be a ` # next_page_token` value returned from a previous `ListBillingAccounts` call. If # unspecified, the first page of results is returned. # @param [String] fields # Selector specifying which fields to include in a partial response. # @param [String] quota_user # Available to use for quota purposes for server-side applications. Can be any # arbitrary string assigned to a user, but should not exceed 40 characters. # @param [Google::Apis::RequestOptions] options # Request-specific options # # @yield [result, err] Result & error if block supplied # @yieldparam result [Google::Apis::CloudbillingV1::ListBillingAccountsResponse] parsed result object # @yieldparam err [StandardError] error object if request failed # # @return [Google::Apis::CloudbillingV1::ListBillingAccountsResponse] # # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification # @raise [Google::Apis::AuthorizationError] Authorization is required def list_billing_accounts(filter: nil, page_size: nil, page_token: nil, fields: nil, quota_user: nil, options: nil, &block) command = make_simple_command(:get, 'v1/billingAccounts', options) command.response_representation = Google::Apis::CloudbillingV1::ListBillingAccountsResponse::Representation command.response_class = Google::Apis::CloudbillingV1::ListBillingAccountsResponse command.query['filter'] = filter unless filter.nil? command.query['pageSize'] = page_size unless page_size.nil? command.query['pageToken'] = page_token unless page_token.nil? command.query['fields'] = fields unless fields.nil? command.query['quotaUser'] = quota_user unless quota_user.nil? execute_or_queue_command(command, &block) end # Updates a billing account's fields. Currently the only field that can be # edited is `display_name`. The current authenticated user must have the ` # billing.accounts.update` IAM permission, which is typically given to the [ # administrator](https://cloud.google.com/billing/docs/how-to/billing-access) of # the billing account. # @param [String] name # Required. The name of the billing account resource to be updated. # @param [Google::Apis::CloudbillingV1::BillingAccount] billing_account_object # @param [String] update_mask # The update mask applied to the resource. Only "display_name" is currently # supported. # @param [String] fields # Selector specifying which fields to include in a partial response. # @param [String] quota_user # Available to use for quota purposes for server-side applications. Can be any # arbitrary string assigned to a user, but should not exceed 40 characters. # @param [Google::Apis::RequestOptions] options # Request-specific options # # @yield [result, err] Result & error if block supplied # @yieldparam result [Google::Apis::CloudbillingV1::BillingAccount] parsed result object # @yieldparam err [StandardError] error object if request failed # # @return [Google::Apis::CloudbillingV1::BillingAccount] # # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification # @raise [Google::Apis::AuthorizationError] Authorization is required def patch_billing_account(name, billing_account_object = nil, update_mask: nil, fields: nil, quota_user: nil, options: nil, &block) command = make_simple_command(:patch, 'v1/{+name}', options) command.request_representation = Google::Apis::CloudbillingV1::BillingAccount::Representation command.request_object = billing_account_object command.response_representation = Google::Apis::CloudbillingV1::BillingAccount::Representation command.response_class = Google::Apis::CloudbillingV1::BillingAccount command.params['name'] = name unless name.nil? command.query['updateMask'] = update_mask unless update_mask.nil? command.query['fields'] = fields unless fields.nil? command.query['quotaUser'] = quota_user unless quota_user.nil? execute_or_queue_command(command, &block) end # Sets the access control policy for a billing account. Replaces any existing # policy. The caller must have the `billing.accounts.setIamPolicy` permission on # the account, which is often given to billing account [administrators](https:// # cloud.google.com/billing/docs/how-to/billing-access). # @param [String] resource # REQUIRED: The resource for which the policy is being specified. See [Resource # names](https://cloud.google.com/apis/design/resource_names) for the # appropriate value for this field. # @param [Google::Apis::CloudbillingV1::SetIamPolicyRequest] set_iam_policy_request_object # @param [String] fields # Selector specifying which fields to include in a partial response. # @param [String] quota_user # Available to use for quota purposes for server-side applications. Can be any # arbitrary string assigned to a user, but should not exceed 40 characters. # @param [Google::Apis::RequestOptions] options # Request-specific options # # @yield [result, err] Result & error if block supplied # @yieldparam result [Google::Apis::CloudbillingV1::Policy] parsed result object # @yieldparam err [StandardError] error object if request failed # # @return [Google::Apis::CloudbillingV1::Policy] # # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification # @raise [Google::Apis::AuthorizationError] Authorization is required def set_billing_account_iam_policy(resource, set_iam_policy_request_object = nil, fields: nil, quota_user: nil, options: nil, &block) command = make_simple_command(:post, 'v1/{+resource}:setIamPolicy', options) command.request_representation = Google::Apis::CloudbillingV1::SetIamPolicyRequest::Representation command.request_object = set_iam_policy_request_object command.response_representation = Google::Apis::CloudbillingV1::Policy::Representation command.response_class = Google::Apis::CloudbillingV1::Policy command.params['resource'] = resource unless resource.nil? command.query['fields'] = fields unless fields.nil? command.query['quotaUser'] = quota_user unless quota_user.nil? execute_or_queue_command(command, &block) end # Tests the access control policy for a billing account. This method takes the # resource and a set of permissions as input and returns the subset of the input # permissions that the caller is allowed for that resource. # @param [String] resource # REQUIRED: The resource for which the policy detail is being requested. See [ # Resource names](https://cloud.google.com/apis/design/resource_names) for the # appropriate value for this field. # @param [Google::Apis::CloudbillingV1::TestIamPermissionsRequest] test_iam_permissions_request_object # @param [String] fields # Selector specifying which fields to include in a partial response. # @param [String] quota_user # Available to use for quota purposes for server-side applications. Can be any # arbitrary string assigned to a user, but should not exceed 40 characters. # @param [Google::Apis::RequestOptions] options # Request-specific options # # @yield [result, err] Result & error if block supplied # @yieldparam result [Google::Apis::CloudbillingV1::TestIamPermissionsResponse] parsed result object # @yieldparam err [StandardError] error object if request failed # # @return [Google::Apis::CloudbillingV1::TestIamPermissionsResponse] # # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification # @raise [Google::Apis::AuthorizationError] Authorization is required def test_billing_account_iam_permissions(resource, test_iam_permissions_request_object = nil, fields: nil, quota_user: nil, options: nil, &block) command = make_simple_command(:post, 'v1/{+resource}:testIamPermissions', options) command.request_representation = Google::Apis::CloudbillingV1::TestIamPermissionsRequest::Representation command.request_object = test_iam_permissions_request_object command.response_representation = Google::Apis::CloudbillingV1::TestIamPermissionsResponse::Representation command.response_class = Google::Apis::CloudbillingV1::TestIamPermissionsResponse command.params['resource'] = resource unless resource.nil? command.query['fields'] = fields unless fields.nil? command.query['quotaUser'] = quota_user unless quota_user.nil? execute_or_queue_command(command, &block) end # Lists the projects associated with a billing account. The current # authenticated user must have the `billing.resourceAssociations.list` IAM # permission, which is often given to billing account [viewers](https://cloud. # google.com/billing/docs/how-to/billing-access). # @param [String] name # Required. The resource name of the billing account associated with the # projects that you want to list. For example, `billingAccounts/012345-567890- # ABCDEF`. # @param [Fixnum] page_size # Requested page size. The maximum page size is 100; this is also the default. # @param [String] page_token # A token identifying a page of results to be returned. This should be a ` # next_page_token` value returned from a previous `ListProjectBillingInfo` call. # If unspecified, the first page of results is returned. # @param [String] fields # Selector specifying which fields to include in a partial response. # @param [String] quota_user # Available to use for quota purposes for server-side applications. Can be any # arbitrary string assigned to a user, but should not exceed 40 characters. # @param [Google::Apis::RequestOptions] options # Request-specific options # # @yield [result, err] Result & error if block supplied # @yieldparam result [Google::Apis::CloudbillingV1::ListProjectBillingInfoResponse] parsed result object # @yieldparam err [StandardError] error object if request failed # # @return [Google::Apis::CloudbillingV1::ListProjectBillingInfoResponse] # # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification # @raise [Google::Apis::AuthorizationError] Authorization is required def list_billing_account_projects(name, page_size: nil, page_token: nil, fields: nil, quota_user: nil, options: nil, &block) command = make_simple_command(:get, 'v1/{+name}/projects', options) command.response_representation = Google::Apis::CloudbillingV1::ListProjectBillingInfoResponse::Representation command.response_class = Google::Apis::CloudbillingV1::ListProjectBillingInfoResponse command.params['name'] = name unless name.nil? command.query['pageSize'] = page_size unless page_size.nil? command.query['pageToken'] = page_token unless page_token.nil? command.query['fields'] = fields unless fields.nil? command.query['quotaUser'] = quota_user unless quota_user.nil? execute_or_queue_command(command, &block) end # Gets the billing information for a project. The current authenticated user # must have the `resourcemanager.projects.get` permission for the project, which # can be granted by assigning the [Project Viewer](https://cloud.google.com/iam/ # docs/understanding-roles#predefined_roles) role. # @param [String] name # Required. The resource name of the project for which billing information is # retrieved. For example, `projects/tokyo-rain-123`. # @param [String] fields # Selector specifying which fields to include in a partial response. # @param [String] quota_user # Available to use for quota purposes for server-side applications. Can be any # arbitrary string assigned to a user, but should not exceed 40 characters. # @param [Google::Apis::RequestOptions] options # Request-specific options # # @yield [result, err] Result & error if block supplied # @yieldparam result [Google::Apis::CloudbillingV1::ProjectBillingInfo] parsed result object # @yieldparam err [StandardError] error object if request failed # # @return [Google::Apis::CloudbillingV1::ProjectBillingInfo] # # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification # @raise [Google::Apis::AuthorizationError] Authorization is required def get_project_billing_info(name, fields: nil, quota_user: nil, options: nil, &block) command = make_simple_command(:get, 'v1/{+name}/billingInfo', options) command.response_representation = Google::Apis::CloudbillingV1::ProjectBillingInfo::Representation command.response_class = Google::Apis::CloudbillingV1::ProjectBillingInfo command.params['name'] = name unless name.nil? command.query['fields'] = fields unless fields.nil? command.query['quotaUser'] = quota_user unless quota_user.nil? execute_or_queue_command(command, &block) end # Sets or updates the billing account associated with a project. You specify the # new billing account by setting the `billing_account_name` in the ` # ProjectBillingInfo` resource to the resource name of a billing account. # Associating a project with an open billing account enables billing on the # project and allows charges for resource usage. If the project already had a # billing account, this method changes the billing account used for resource # usage charges. *Note:* Incurred charges that have not yet been reported in the # transaction history of the Google Cloud Console might be billed to the new # billing account, even if the charge occurred before the new billing account # was assigned to the project. The current authenticated user must have # ownership privileges for both the [project](https://cloud.google.com/docs/ # permissions-overview#h.bgs0oxofvnoo ) and the [billing account](https://cloud. # google.com/billing/docs/how-to/billing-access). You can disable billing on the # project by setting the `billing_account_name` field to empty. This action # disassociates the current billing account from the project. Any billable # activity of your in-use services will stop, and your application could stop # functioning as expected. Any unbilled charges to date will be billed to the # previously associated account. The current authenticated user must be either # an owner of the project or an owner of the billing account for the project. # Note that associating a project with a *closed* billing account will have much # the same effect as disabling billing on the project: any paid resources used # by the project will be shut down. Thus, unless you wish to disable billing, # you should always call this method with the name of an *open* billing account. # @param [String] name # Required. The resource name of the project associated with the billing # information that you want to update. For example, `projects/tokyo-rain-123`. # @param [Google::Apis::CloudbillingV1::ProjectBillingInfo] project_billing_info_object # @param [String] fields # Selector specifying which fields to include in a partial response. # @param [String] quota_user # Available to use for quota purposes for server-side applications. Can be any # arbitrary string assigned to a user, but should not exceed 40 characters. # @param [Google::Apis::RequestOptions] options # Request-specific options # # @yield [result, err] Result & error if block supplied # @yieldparam result [Google::Apis::CloudbillingV1::ProjectBillingInfo] parsed result object # @yieldparam err [StandardError] error object if request failed # # @return [Google::Apis::CloudbillingV1::ProjectBillingInfo] # # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification # @raise [Google::Apis::AuthorizationError] Authorization is required def update_project_billing_info(name, project_billing_info_object = nil, fields: nil, quota_user: nil, options: nil, &block) command = make_simple_command(:put, 'v1/{+name}/billingInfo', options) command.request_representation = Google::Apis::CloudbillingV1::ProjectBillingInfo::Representation command.request_object = project_billing_info_object command.response_representation = Google::Apis::CloudbillingV1::ProjectBillingInfo::Representation command.response_class = Google::Apis::CloudbillingV1::ProjectBillingInfo command.params['name'] = name unless name.nil? command.query['fields'] = fields unless fields.nil? command.query['quotaUser'] = quota_user unless quota_user.nil? execute_or_queue_command(command, &block) end # Lists all public cloud services. # @param [Fixnum] page_size # Requested page size. Defaults to 5000. # @param [String] page_token # A token identifying a page of results to return. This should be a ` # next_page_token` value returned from a previous `ListServices` call. If # unspecified, the first page of results is returned. # @param [String] fields # Selector specifying which fields to include in a partial response. # @param [String] quota_user # Available to use for quota purposes for server-side applications. Can be any # arbitrary string assigned to a user, but should not exceed 40 characters. # @param [Google::Apis::RequestOptions] options # Request-specific options # # @yield [result, err] Result & error if block supplied # @yieldparam result [Google::Apis::CloudbillingV1::ListServicesResponse] parsed result object # @yieldparam err [StandardError] error object if request failed # # @return [Google::Apis::CloudbillingV1::ListServicesResponse] # # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification # @raise [Google::Apis::AuthorizationError] Authorization is required def list_services(page_size: nil, page_token: nil, fields: nil, quota_user: nil, options: nil, &block) command = make_simple_command(:get, 'v1/services', options) command.response_representation = Google::Apis::CloudbillingV1::ListServicesResponse::Representation command.response_class = Google::Apis::CloudbillingV1::ListServicesResponse command.query['pageSize'] = page_size unless page_size.nil? command.query['pageToken'] = page_token unless page_token.nil? command.query['fields'] = fields unless fields.nil? command.query['quotaUser'] = quota_user unless quota_user.nil? execute_or_queue_command(command, &block) end # Lists all publicly available SKUs for a given cloud service. # @param [String] parent # Required. The name of the service. Example: "services/DA34-426B-A397" # @param [String] currency_code # The ISO 4217 currency code for the pricing info in the response proto. Will # use the conversion rate as of start_time. Optional. If not specified USD will # be used. # @param [String] end_time # Optional exclusive end time of the time range for which the pricing versions # will be returned. Timestamps in the future are not allowed. The time range has # to be within a single calendar month in America/Los_Angeles timezone. Time # range as a whole is optional. If not specified, the latest pricing will be # returned (up to 12 hours old at most). # @param [Fixnum] page_size # Requested page size. Defaults to 5000. # @param [String] page_token # A token identifying a page of results to return. This should be a ` # next_page_token` value returned from a previous `ListSkus` call. If # unspecified, the first page of results is returned. # @param [String] start_time # Optional inclusive start time of the time range for which the pricing versions # will be returned. Timestamps in the future are not allowed. The time range has # to be within a single calendar month in America/Los_Angeles timezone. Time # range as a whole is optional. If not specified, the latest pricing will be # returned (up to 12 hours old at most). # @param [String] fields # Selector specifying which fields to include in a partial response. # @param [String] quota_user # Available to use for quota purposes for server-side applications. Can be any # arbitrary string assigned to a user, but should not exceed 40 characters. # @param [Google::Apis::RequestOptions] options # Request-specific options # # @yield [result, err] Result & error if block supplied # @yieldparam result [Google::Apis::CloudbillingV1::ListSkusResponse] parsed result object # @yieldparam err [StandardError] error object if request failed # # @return [Google::Apis::CloudbillingV1::ListSkusResponse] # # @raise [Google::Apis::ServerError] An error occurred on the server and the request can be retried # @raise [Google::Apis::ClientError] The request is invalid and should not be retried without modification # @raise [Google::Apis::AuthorizationError] Authorization is required def list_service_skus(parent, currency_code: nil, end_time: nil, page_size: nil, page_token: nil, start_time: nil, fields: nil, quota_user: nil, options: nil, &block) command = make_simple_command(:get, 'v1/{+parent}/skus', options) command.response_representation = Google::Apis::CloudbillingV1::ListSkusResponse::Representation command.response_class = Google::Apis::CloudbillingV1::ListSkusResponse command.params['parent'] = parent unless parent.nil? command.query['currencyCode'] = currency_code unless currency_code.nil? command.query['endTime'] = end_time unless end_time.nil? command.query['pageSize'] = page_size unless page_size.nil? command.query['pageToken'] = page_token unless page_token.nil? command.query['startTime'] = start_time unless start_time.nil? command.query['fields'] = fields unless fields.nil? command.query['quotaUser'] = quota_user unless quota_user.nil? execute_or_queue_command(command, &block) end protected def apply_command_defaults(command) command.query['key'] = key unless key.nil? command.query['quotaUser'] = quota_user unless quota_user.nil? end end end end end google-apis-cloudbilling-v1-0.21.0/lib/google-apis-cloudbilling_v1.rb0000644000175000017500000000114614413340637024040 0ustar raviravi# Copyright 2020 Google LLC # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. require "google/apis/cloudbilling_v1" google-apis-cloudbilling-v1-0.21.0/OVERVIEW.md0000644000175000017500000001374014413340637017257 0ustar raviravi# Simple REST client for version V1 of the Cloud Billing API This is a simple client library for version V1 of the Cloud Billing API. It provides: * A client object that connects to the HTTP/JSON REST endpoint for the service. * Ruby objects for data structures related to the service. * Integration with the googleauth gem for authentication using OAuth, API keys, and service accounts. * Control of retry, pagination, and timeouts. Note that although this client library is supported and will continue to be updated to track changes to the service, it is otherwise considered complete and not under active development. Many Google services, especially Google Cloud Platform services, may provide a more modern client that is under more active development and improvement. See the section below titled *Which client should I use?* for more information. ## Getting started ### Before you begin There are a few setup steps you need to complete before you can use this library: 1. If you don't already have a Google account, [sign up](https://www.google.com/accounts). 2. If you have never created a Google APIs Console project, read about [Managing Projects](https://cloud.google.com/resource-manager/docs/creating-managing-projects) and create a project in the [Google API Console](https://console.cloud.google.com/). 3. Most APIs need to be enabled for your project. [Enable it](https://console.cloud.google.com/apis/library/cloudbilling.googleapis.com) in the console. ### Installation Add this line to your application's Gemfile: ```ruby gem 'google-apis-cloudbilling_v1', '~> 0.1' ``` And then execute: ``` $ bundle ``` Or install it yourself as: ``` $ gem install google-apis-cloudbilling_v1 ``` ### Creating a client object Once the gem is installed, you can load the client code and instantiate a client. ```ruby # Load the client require "google/apis/cloudbilling_v1" # Create a client object client = Google::Apis::CloudbillingV1::CloudbillingService.new # Authenticate calls client.authorization = # ... use the googleauth gem to create credentials ``` See the class reference docs for information on the methods you can call from a client. ## Documentation More detailed descriptions of the Google simple REST clients are available in two documents. * The [Usage Guide](https://github.com/googleapis/google-api-ruby-client/blob/main/docs/usage-guide.md) discusses how to make API calls, how to use the provided data structures, and how to work the various features of the client library, including media upload and download, error handling, retries, pagination, and logging. * The [Auth Guide](https://github.com/googleapis/google-api-ruby-client/blob/main/docs/auth-guide.md) discusses authentication in the client libraries, including API keys, OAuth 2.0, service accounts, and environment variables. (Note: the above documents are written for the simple REST clients in general, and their examples may not reflect the Cloudbilling service in particular.) For reference information on specific calls in the Cloud Billing API, see the {Google::Apis::CloudbillingV1::CloudbillingService class reference docs}. ## Which client should I use? Google provides two types of Ruby API client libraries: **simple REST clients** and **modern clients**. This library, `google-apis-cloudbilling_v1`, is a simple REST client. You can identify these clients by their gem names, which are always in the form `google-apis-_`. The simple REST clients connect to HTTP/JSON REST endpoints and are automatically generated from service discovery documents. They support most API functionality, but their class interfaces are sometimes awkward. Modern clients are produced by a modern code generator, sometimes combined with hand-crafted functionality. Most modern clients connect to high-performance gRPC endpoints, although a few are backed by REST services. Modern clients are available for many Google services, especially Google Cloud Platform services, but do not yet support all the services covered by the simple clients. Gem names for modern clients are often of the form `google-cloud-`. (For example, [google-cloud-pubsub](https://rubygems.org/gems/google-cloud-pubsub).) Note that most modern clients also have corresponding "versioned" gems with names like `google-cloud--`. (For example, [google-cloud-pubsub-v1](https://rubygems.org/gems/google-cloud-pubsub-v1).) The "versioned" gems can be used directly, but often provide lower-level interfaces. In most cases, the main gem is recommended. **For most users, we recommend the modern client, if one is available.** Compared with simple clients, modern clients are generally much easier to use and more Ruby-like, support more advanced features such as streaming and long-running operations, and often provide much better performance. You may consider using a simple client instead, if a modern client is not yet available for the service you want to use, or if you are not able to use gRPC on your infrastructure. The [product documentation](https://cloud.google.com/billing/) may provide guidance regarding the preferred client library to use. ## Supported Ruby versions This library is supported on Ruby 2.5+. Google provides official support for Ruby versions that are actively supported by Ruby Core -- that is, Ruby versions that are either in normal maintenance or in security maintenance, and not end of life. Currently, this means Ruby 2.5 and later. Older versions of Ruby _may_ still work, but are unsupported and not recommended. See https://www.ruby-lang.org/en/downloads/branches/ for details about the Ruby support schedule. ## License This library is licensed under Apache 2.0. Full license text is available in the {file:LICENSE.md LICENSE}. ## Support Please [report bugs at the project on Github](https://github.com/google/google-api-ruby-client/issues). Don't hesitate to [ask questions](http://stackoverflow.com/questions/tagged/google-api-ruby-client) about the client or APIs on [StackOverflow](http://stackoverflow.com). google-apis-cloudbilling-v1-0.21.0/.yardopts0000644000175000017500000000037514413340637017335 0ustar raviravi--hide-void-return --no-private --verbose --title=google-apis-cloudbilling_v1 --markup-provider=redcarpet --markup=markdown --main OVERVIEW.md lib/google/apis/cloudbilling_v1/*.rb lib/google/apis/cloudbilling_v1.rb - OVERVIEW.md CHANGELOG.md LICENSE.md google-apis-cloudbilling-v1-0.21.0/CHANGELOG.md0000644000175000017500000000340714413340637017277 0ustar raviravi# Release history for google-apis-cloudbilling_v1 ### v0.21.0 (2022-10-19) * Regenerated using generator version 0.11.0 ### v0.20.0 (2022-09-21) * Regenerated using generator version 0.10.0 ### v0.19.0 (2022-09-10) * Regenerated from discovery document revision 20220908 ### v0.18.0 (2022-08-27) * Regenerated from discovery document revision 20220817 * Regenerated using generator version 0.9.0 ### v0.17.0 (2022-06-30) * Regenerated using generator version 0.8.0 ### v0.16.0 (2022-06-17) * Regenerated using generator version 0.6.0 ### v0.15.0 (2022-06-04) * Regenerated using generator version 0.5.0 ### v0.14.0 (2022-05-03) * Regenerated from discovery document revision 20220430 ### v0.13.0 (2022-04-05) * Regenerated from discovery document revision 20220402 * Regenerated using generator version 0.4.1 ### v0.12.0 (2021-12-14) * Regenerated from discovery document revision 20211211 ### v0.11.0 (2021-11-09) * Regenerated from discovery document revision 20211106 ### v0.10.0 (2021-10-20) * Unspecified changes ### v0.9.0 (2021-10-12) * Regenerated from discovery document revision 20211007 ### v0.8.0 (2021-10-05) * Regenerated from discovery document revision 20211004 ### v0.7.0 (2021-08-31) * Regenerated from discovery document revision 20210827 ### v0.6.0 (2021-06-29) * Regenerated using generator version 0.4.0 ### v0.5.0 (2021-06-24) * Regenerated using generator version 0.3.0 ### v0.4.0 (2021-05-19) * Unspecified changes ### v0.3.0 (2021-03-24) * Regenerated from discovery document revision 20210322 * Regenerated using generator version 0.2.0 ### v0.2.0 (2021-03-04) * Regenerated using generator version 0.1.2 ### v0.1.0 (2021-01-07) * Regenerated using generator version 0.1.1 * Regenerated from discovery document revision 20201017