From ffeb5088b7f259a9db9979844af269d4ea792b76 Mon Sep 17 00:00:00 2001 From: Yoshi Automation Bot Date: Fri, 13 Oct 2023 00:22:14 -0700 Subject: [PATCH] feat(all): auto-regenerate discovery clients (#2216) --- .../v1/accesscontextmanager-api.json | 4 +- .../v1/accesscontextmanager-gen.go | 6 +- androidpublisher/v3/androidpublisher-api.json | 6 +- androidpublisher/v3/androidpublisher-gen.go | 17 +- appengine/v1beta/appengine-api.json | 204 ++- appengine/v1beta/appengine-gen.go | 608 +++++---- chromepolicy/v1/chromepolicy-api.json | 10 +- chromepolicy/v1/chromepolicy-gen.go | 11 +- compute/v0.beta/compute-api.json | 12 +- compute/v0.beta/compute-gen.go | 13 +- content/v2.1/content-api.json | 16 +- content/v2.1/content-gen.go | 24 +- displayvideo/v3/displayvideo-api.json | 6 +- displayvideo/v3/displayvideo-gen.go | 4 +- dlp/v2/dlp-api.json | 16 +- dlp/v2/dlp-gen.go | 36 +- run/v1/run-api.json | 8 +- run/v1/run-gen.go | 6 + .../v1/travelimpactmodel-api.json | 4 +- travelimpactmodel/v1/travelimpactmodel-gen.go | 5 +- youtube/v3/youtube-api.json | 242 +++- youtube/v3/youtube-gen.go | 1108 +++++++++++++++-- 22 files changed, 1739 insertions(+), 627 deletions(-) diff --git a/accesscontextmanager/v1/accesscontextmanager-api.json b/accesscontextmanager/v1/accesscontextmanager-api.json index 548162eff8e..4c3c5a104e8 100644 --- a/accesscontextmanager/v1/accesscontextmanager-api.json +++ b/accesscontextmanager/v1/accesscontextmanager-api.json @@ -1235,7 +1235,7 @@ } } }, - "revision": "20230910", + "revision": "20231011", "rootUrl": "https://accesscontextmanager.googleapis.com/", "schemas": { "AccessContextManagerOperationMetadata": { @@ -1793,7 +1793,7 @@ "type": "object" }, "GcpUserAccessBindingOperationMetadata": { - "description": "Currently, a completed operation means nothing. In the future, this metadata and a completed operation may indicate that the binding has taken effect and is affecting access decisions for all users.", + "description": "Metadata of GCP Access Binding Long Running Operations.", "id": "GcpUserAccessBindingOperationMetadata", "properties": {}, "type": "object" diff --git a/accesscontextmanager/v1/accesscontextmanager-gen.go b/accesscontextmanager/v1/accesscontextmanager-gen.go index 377a3bdf45a..87652a77c5b 100644 --- a/accesscontextmanager/v1/accesscontextmanager-gen.go +++ b/accesscontextmanager/v1/accesscontextmanager-gen.go @@ -1291,10 +1291,8 @@ func (s *GcpUserAccessBinding) MarshalJSON() ([]byte, error) { return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) } -// GcpUserAccessBindingOperationMetadata: Currently, a completed -// operation means nothing. In the future, this metadata and a completed -// operation may indicate that the binding has taken effect and is -// affecting access decisions for all users. +// GcpUserAccessBindingOperationMetadata: Metadata of GCP Access Binding +// Long Running Operations. type GcpUserAccessBindingOperationMetadata struct { } diff --git a/androidpublisher/v3/androidpublisher-api.json b/androidpublisher/v3/androidpublisher-api.json index ff598251589..090fb25712b 100644 --- a/androidpublisher/v3/androidpublisher-api.json +++ b/androidpublisher/v3/androidpublisher-api.json @@ -3171,7 +3171,7 @@ "orders": { "methods": { "refund": { - "description": "Refunds a user's subscription or in-app purchase order. Orders older than 1 year cannot be refunded.", + "description": "Refunds a user's subscription or in-app purchase order. Orders older than 3 years cannot be refunded.", "flatPath": "androidpublisher/v3/applications/{packageName}/orders/{orderId}:refund", "httpMethod": "POST", "id": "androidpublisher.orders.refund", @@ -4047,7 +4047,7 @@ } } }, - "revision": "20231010", + "revision": "20231012", "rootUrl": "https://androidpublisher.googleapis.com/", "schemas": { "Abi": { @@ -6395,7 +6395,7 @@ "id": "RegionalPriceMigrationConfig", "properties": { "oldestAllowedPriceVersionTime": { - "description": "Required. The cutoff time for historical prices that subscribers can remain paying. Subscribers who are on a price that was created before this cutoff time will be migrated to the currently-offered price. These subscribers will receive a notification that they will be paying a different price. Subscribers who do not agree to the new price will have their subscription ended at the next renewal.", + "description": "Required. The cutoff time for historical prices that subscribers can remain paying. Subscribers on prices which were available at this cutoff time or later will stay on their existing price. Subscribers on older prices will be migrated to the currently-offered price. The migrated subscribers will receive a notification that they will be paying a different price. Subscribers who do not agree to the new price will have their subscription ended at the next renewal.", "format": "google-datetime", "type": "string" }, diff --git a/androidpublisher/v3/androidpublisher-gen.go b/androidpublisher/v3/androidpublisher-gen.go index 246ad599e6d..99853578f69 100644 --- a/androidpublisher/v3/androidpublisher-gen.go +++ b/androidpublisher/v3/androidpublisher-gen.go @@ -4595,12 +4595,13 @@ func (s *RegionalBasePlanConfig) MarshalJSON() ([]byte, error) { // RegionalPriceMigrationConfig: Configuration for a price migration. type RegionalPriceMigrationConfig struct { // OldestAllowedPriceVersionTime: Required. The cutoff time for - // historical prices that subscribers can remain paying. Subscribers who - // are on a price that was created before this cutoff time will be - // migrated to the currently-offered price. These subscribers will - // receive a notification that they will be paying a different price. - // Subscribers who do not agree to the new price will have their - // subscription ended at the next renewal. + // historical prices that subscribers can remain paying. Subscribers on + // prices which were available at this cutoff time or later will stay on + // their existing price. Subscribers on older prices will be migrated to + // the currently-offered price. The migrated subscribers will receive a + // notification that they will be paying a different price. Subscribers + // who do not agree to the new price will have their subscription ended + // at the next renewal. OldestAllowedPriceVersionTime string `json:"oldestAllowedPriceVersionTime,omitempty"` // PriceIncreaseType: Optional. The behavior the caller wants users to @@ -19846,7 +19847,7 @@ type OrdersRefundCall struct { } // Refund: Refunds a user's subscription or in-app purchase order. -// Orders older than 1 year cannot be refunded. +// Orders older than 3 years cannot be refunded. // // - orderId: The order ID provided to the user when the subscription or // in-app order was purchased. @@ -19932,7 +19933,7 @@ func (c *OrdersRefundCall) Do(opts ...googleapi.CallOption) error { } return nil // { - // "description": "Refunds a user's subscription or in-app purchase order. Orders older than 1 year cannot be refunded.", + // "description": "Refunds a user's subscription or in-app purchase order. Orders older than 3 years cannot be refunded.", // "flatPath": "androidpublisher/v3/applications/{packageName}/orders/{orderId}:refund", // "httpMethod": "POST", // "id": "androidpublisher.orders.refund", diff --git a/appengine/v1beta/appengine-api.json b/appengine/v1beta/appengine-api.json index 775135c14bd..aeb053596d5 100644 --- a/appengine/v1beta/appengine-api.json +++ b/appengine/v1beta/appengine-api.json @@ -171,6 +171,47 @@ "https://www.googleapis.com/auth/cloud-platform.read-only" ] }, + "listRuntimes": { + "description": "Lists all the available runtimes for the application.", + "flatPath": "v1beta/apps/{appsId}:listRuntimes", + "httpMethod": "GET", + "id": "appengine.apps.listRuntimes", + "parameterOrder": [ + "appsId" + ], + "parameters": { + "appsId": { + "description": "Part of `parent`. Required. Name of the parent Application resource. Example: apps/myapp.", + "location": "path", + "required": true, + "type": "string" + }, + "environment": { + "description": "Optional. The environment of the Application.", + "enum": [ + "ENVIRONMENT_UNSPECIFIED", + "STANDARD", + "FLEXIBLE" + ], + "enumDescriptions": [ + "Default value.", + "App Engine Standard.", + "App Engine Flexible" + ], + "location": "query", + "type": "string" + } + }, + "path": "v1beta/apps/{appsId}:listRuntimes", + "response": { + "$ref": "ListRuntimesResponse" + }, + "scopes": [ + "https://www.googleapis.com/auth/appengine.admin", + "https://www.googleapis.com/auth/cloud-platform", + "https://www.googleapis.com/auth/cloud-platform.read-only" + ] + }, "patch": { "description": "Updates the specified Application resource. You can update the following fields: auth_domain - Google authentication domain for controlling user access to the application. default_cookie_expiration - Cookie expiration policy for the application. iap - Identity-Aware Proxy properties for the application.", "flatPath": "v1beta/apps/{appsId}", @@ -1025,51 +1066,6 @@ } } }, - "runtimes": { - "methods": { - "list": { - "description": "Lists all the available runtimes for the application.", - "flatPath": "v1beta/apps/{appsId}/runtimes", - "httpMethod": "GET", - "id": "appengine.apps.runtimes.list", - "parameterOrder": [ - "appsId" - ], - "parameters": { - "appsId": { - "description": "Part of `parent`. Required. Name of the parent Application resource. Example: apps/myapp.", - "location": "path", - "required": true, - "type": "string" - }, - "environment": { - "description": "Optional. The environment of the Application.", - "enum": [ - "ENVIRONMENT_UNSPECIFIED", - "STANDARD", - "FLEXIBLE" - ], - "enumDescriptions": [ - "Default value.", - "App Engine Standard.", - "App Engine Flexible" - ], - "location": "query", - "type": "string" - } - }, - "path": "v1beta/apps/{appsId}/runtimes", - "response": { - "$ref": "ListRuntimesResponse" - }, - "scopes": [ - "https://www.googleapis.com/auth/appengine.admin", - "https://www.googleapis.com/auth/cloud-platform", - "https://www.googleapis.com/auth/cloud-platform.read-only" - ] - } - } - }, "services": { "methods": { "delete": { @@ -1863,7 +1859,7 @@ } } }, - "revision": "20230925", + "revision": "20231004", "rootUrl": "https://appengine.googleapis.com/", "schemas": { "ApiConfigHandler": { @@ -2285,6 +2281,38 @@ }, "type": "object" }, + "ContainerState": { + "description": "ContainerState contains the externally-visible container state that is used to communicate the state and reasoning for that state to the CLH. This data is not persisted by CCFE, but is instead derived from CCFE's internal representation of the container state.", + "id": "ContainerState", + "properties": { + "currentReasons": { + "$ref": "Reasons", + "deprecated": true + }, + "previousReasons": { + "$ref": "Reasons", + "deprecated": true, + "description": "The previous and current reasons for a container state will be sent for a container event. CLHs that need to know the signal that caused the container event to trigger (edges) as opposed to just knowing the state can act upon differences in the previous and current reasons.Reasons will be provided for every system: service management, data governance, abuse, and billing.If this is a CCFE-triggered event used for reconciliation then the current reasons will be set to their *_CONTROL_PLANE_SYNC state. The previous reasons will contain the last known set of non-unknown non-control_plane_sync reasons for the state.Reasons fields are deprecated. New tenants should only use the state field. If you must know the reason(s) behind a specific state, please consult with CCFE team first (cloud-ccfe-discuss@google.com)." + }, + "state": { + "description": "The current state of the container. This state is the culmination of all of the opinions from external systems that CCFE knows about of the container.", + "enum": [ + "UNKNOWN_STATE", + "ON", + "OFF", + "DELETED" + ], + "enumDescriptions": [ + "A container should never be in an unknown state. Receipt of a container with this state is an error.", + "CCFE considers the container to be serving or transitioning into serving.", + "CCFE considers the container to be in an OFF state. This could occur due to various factors. The state could be triggered by Google-internal audits (ex. abuse suspension, billing closed) or cleanups trigged by compliance systems (ex. data governance hide). User-initiated events such as service management deactivation trigger a container to an OFF state.CLHs might choose to do nothing in this case or to turn off costly resources. CLHs need to consider the customer experience if an ON/OFF/ON sequence of state transitions occurs vs. the cost of deleting resources, keeping metadata about resources, or even keeping resources live for a period of time.CCFE will not send any new customer requests to the CLH when the container is in an OFF state. However, CCFE will allow all previous customer requests relayed to CLH to complete.", + "This state indicates that the container has been (or is being) completely removed. This is often due to a data governance purge request and therefore resources should be deleted when this state is reached." + ], + "type": "string" + } + }, + "type": "object" + }, "CpuUtilization": { "description": "Target scaling by CPU usage.", "id": "CpuUtilization", @@ -3473,44 +3501,12 @@ "description": "The projects metadata for this project. required" }, "state": { - "$ref": "ProjectState", + "$ref": "ContainerState", "description": "The state of the project that led to this event." } }, "type": "object" }, - "ProjectState": { - "description": "ProjectState contains the externally-visible project state that is used to communicate the state and reasoning for that state to the CLH. This data is not persisted by CCFE, but is instead derived from CCFE's internal representation of the project state.", - "id": "ProjectState", - "properties": { - "currentReasons": { - "$ref": "Reasons", - "deprecated": true - }, - "previousReasons": { - "$ref": "Reasons", - "deprecated": true, - "description": "The previous and current reasons for a project state will be sent for a project event. CLHs that need to know the signal that caused the project event to trigger (edges) as opposed to just knowing the state can act upon differences in the previous and current reasons.Reasons will be provided for every system: service management, data governance, abuse, and billing.If this is a CCFE-triggered event used for reconciliation then the current reasons will be set to their *_CONTROL_PLANE_SYNC state. The previous reasons will contain the last known set of non-unknown non-control_plane_sync reasons for the state.Reasons fields are deprecated. New tenants should only use the state field. If you must know the reason(s) behind a specific state, please consult with CCFE team first (cloud-ccfe-discuss@google.com)." - }, - "state": { - "description": "The current state of the project. This state is the culmination of all of the opinions from external systems that CCFE knows about of the project.", - "enum": [ - "UNKNOWN_STATE", - "ON", - "OFF", - "DELETED" - ], - "enumDescriptions": [ - "A project should never be in an unknown state. Receipt of a project with this state is an error.", - "CCFE considers the project to be serving or transitioning into serving.", - "CCFE considers the project to be in an OFF state. This could occur due to various factors. The state could be triggered by Google-internal audits (ex. abuse suspension, billing closed) or cleanups trigged by compliance systems (ex. data governance hide). User-initiated events such as service management deactivation trigger a project to an OFF state.CLHs might choose to do nothing in this case or to turn off costly resources. CLHs need to consider the customer experience if an ON/OFF/ON sequence of state transitions occurs vs. the cost of deleting resources, keeping metadata about resources, or even keeping resources live for a period of time.CCFE will not send any new customer requests to the CLH when the project is in an OFF state. However, CCFE will allow all previous customer requests relayed to CLH to complete.", - "This state indicates that the project has been (or is being) completely removed. This is often due to a data governance purge request and therefore resources should be deleted when this state is reached." - ], - "type": "string" - } - }, - "type": "object" - }, "ProjectsMetadata": { "description": "ProjectsMetadata is the metadata CCFE stores about the all the relevant projects (tenant, consumer, producer).", "id": "ProjectsMetadata", @@ -3533,10 +3529,10 @@ "DELETED" ], "enumDescriptions": [ - "A project should never be in an unknown state. Receipt of a project with this state is an error.", - "CCFE considers the project to be serving or transitioning into serving.", - "CCFE considers the project to be in an OFF state. This could occur due to various factors. The state could be triggered by Google-internal audits (ex. abuse suspension, billing closed) or cleanups trigged by compliance systems (ex. data governance hide). User-initiated events such as service management deactivation trigger a project to an OFF state.CLHs might choose to do nothing in this case or to turn off costly resources. CLHs need to consider the customer experience if an ON/OFF/ON sequence of state transitions occurs vs. the cost of deleting resources, keeping metadata about resources, or even keeping resources live for a period of time.CCFE will not send any new customer requests to the CLH when the project is in an OFF state. However, CCFE will allow all previous customer requests relayed to CLH to complete.", - "This state indicates that the project has been (or is being) completely removed. This is often due to a data governance purge request and therefore resources should be deleted when this state is reached." + "A container should never be in an unknown state. Receipt of a container with this state is an error.", + "CCFE considers the container to be serving or transitioning into serving.", + "CCFE considers the container to be in an OFF state. This could occur due to various factors. The state could be triggered by Google-internal audits (ex. abuse suspension, billing closed) or cleanups trigged by compliance systems (ex. data governance hide). User-initiated events such as service management deactivation trigger a container to an OFF state.CLHs might choose to do nothing in this case or to turn off costly resources. CLHs need to consider the customer experience if an ON/OFF/ON sequence of state transitions occurs vs. the cost of deleting resources, keeping metadata about resources, or even keeping resources live for a period of time.CCFE will not send any new customer requests to the CLH when the container is in an OFF state. However, CCFE will allow all previous customer requests relayed to CLH to complete.", + "This state indicates that the container has been (or is being) completely removed. This is often due to a data governance purge request and therefore resources should be deleted when this state is reached." ], "type": "string" }, @@ -3606,7 +3602,7 @@ "type": "object" }, "Reasons": { - "description": "Projects transition between and within states based on reasons sent from various systems. CCFE will provide the CLH with reasons for the current state per system.The current systems that CCFE supports are: Service Management (Inception) Data Governance (Wipeout) Abuse (Ares) Billing (Internal Cloud Billing API)", + "description": "Containers transition between and within states based on reasons sent from various systems. CCFE will provide the CLH with reasons for the current state per system.The current systems that CCFE supports are: Service Management (Inception) Data Governance (Wipeout) Abuse (Ares) Billing (Internal Cloud Billing API)", "id": "Reasons", "properties": { "abuse": { @@ -3617,10 +3613,10 @@ "REINSTATE" ], "enumDescriptions": [ - "An unknown reason indicates that the abuse system has not sent a signal for this project.", - "Due to various reasons CCFE might proactively restate a project state to a CLH to ensure that the CLH and CCFE are both aware of the project state. This reason can be tied to any of the states.", - "If a project is deemed abusive we receive a suspend signal. Suspend is a reason to put the project into an INTERNAL_OFF state.", - "Projects that were once considered abusive can later be deemed non-abusive. When this happens we must reinstate the project. Reinstate is a reason to put the project into an ON state." + "An unknown reason indicates that the abuse system has not sent a signal for this container.", + "Due to various reasons CCFE might proactively restate a container state to a CLH to ensure that the CLH and CCFE are both aware of the container state. This reason can be tied to any of the states.", + "If a container is deemed abusive we receive a suspend signal. Suspend is a reason to put the container into an INTERNAL_OFF state.", + "Containers that were once considered abusive can later be deemed non-abusive. When this happens we must reinstate the container. Reinstate is a reason to put the container into an ON state." ], "type": "string" }, @@ -3633,11 +3629,11 @@ "OPEN" ], "enumDescriptions": [ - "An unknown reason indicates that the billing system has not sent a signal for this project.", - "Due to various reasons CCFE might proactively restate a project state to a CLH to ensure that the CLH and CCFE are both aware of the project state. This reason can be tied to any of the states.", - "Minor infractions cause a probation signal to be sent. Probation is a reason to put the project into a ON state even though it is a negative signal. CCFE will block mutations for this project while it is on billing probation, but the CLH is expected to serve non-mutation requests.", - "When a billing account is closed, it is a stronger signal about non-payment. Close is a reason to put the project into an INTERNAL_OFF state.", - "Consumers can re-open billing accounts and update accounts to pull them out of probation. When this happens, we get a signal that the account is open. Open is a reason to put the project into an ON state." + "An unknown reason indicates that the billing system has not sent a signal for this container.", + "Due to various reasons CCFE might proactively restate a container state to a CLH to ensure that the CLH and CCFE are both aware of the container state. This reason can be tied to any of the states.", + "Minor infractions cause a probation signal to be sent. Probation is a reason to put the container into a ON state even though it is a negative signal. CCFE will block mutations for this container while it is on billing probation, but the CLH is expected to serve non-mutation requests.", + "When a billing account is closed, it is a stronger signal about non-payment. Close is a reason to put the container into an INTERNAL_OFF state.", + "Consumers can re-open billing accounts and update accounts to pull them out of probation. When this happens, we get a signal that the account is open. Open is a reason to put the container into an ON state." ], "type": "string" }, @@ -3650,11 +3646,11 @@ "PURGE" ], "enumDescriptions": [ - "An unknown reason indicates that data governance has not sent a signal for this project.", - "Due to various reasons CCFE might proactively restate a project state to a CLH to ensure that the CLH and CCFE are both aware of the project state. This reason can be tied to any of the states.", - "When a project is deleted we retain some data for a period of time to allow the consumer to change their mind. Data governance sends a signal to hide the data when this occurs. Hide is a reason to put the project in an INTERNAL_OFF state.", - "The decision to un-delete a project can be made. When this happens data governance tells us to unhide any hidden data. Unhide is a reason to put the project in an ON state.", - "After a period of time data must be completely removed from our systems. When data governance sends a purge signal we need to remove data. Purge is a reason to put the project in a DELETED state. Purge is the only event that triggers a delete mutation. All other events have update semantics." + "An unknown reason indicates that data governance has not sent a signal for this container.", + "Due to various reasons CCFE might proactively restate a container state to a CLH to ensure that the CLH and CCFE are both aware of the container state. This reason can be tied to any of the states.", + "When a container is deleted we retain some data for a period of time to allow the consumer to change their mind. Data governance sends a signal to hide the data when this occurs. Hide is a reason to put the container in an INTERNAL_OFF state.", + "The decision to un-delete a container can be made. When this happens data governance tells us to unhide any hidden data. Unhide is a reason to put the container in an ON state.", + "After a period of time data must be completely removed from our systems. When data governance sends a purge signal we need to remove data. Purge is a reason to put the container in a DELETED state. Purge is the only event that triggers a delete mutation. All other events have update semantics." ], "type": "string" }, @@ -3676,12 +3672,12 @@ true ], "enumDescriptions": [ - "An unknown reason indicates that we have not received a signal from service management about this project. Since projects are created by request of service management, this reason should never be set.", - "Due to various reasons CCFE might proactively restate a project state to a CLH to ensure that the CLH and CCFE are both aware of the project state. This reason can be tied to any of the states.", - "When a customer activates an API CCFE notifies the CLH and sets the project to the ON state.", - "When a customer deactivates and API service management starts a two-step process to perform the deactivation. The first step is to prepare. Prepare is a reason to put the project in a EXTERNAL_OFF state.", - "If the deactivation is cancelled, service managed needs to abort the deactivation. Abort is a reason to put the project in an ON state.", - "If the deactivation is followed through with, service management needs to finish deactivation. Commit is a reason to put the project in a DELETED state." + "An unknown reason indicates that we have not received a signal from service management about this container. Since containers are created by request of service management, this reason should never be set.", + "Due to various reasons CCFE might proactively restate a container state to a CLH to ensure that the CLH and CCFE are both aware of the container state. This reason can be tied to any of the states.", + "When a customer activates an API CCFE notifies the CLH and sets the container to the ON state.", + "When a customer deactivates and API service management starts a two-step process to perform the deactivation. The first step is to prepare. Prepare is a reason to put the container in a EXTERNAL_OFF state.", + "If the deactivation is cancelled, service managed needs to abort the deactivation. Abort is a reason to put the container in an ON state.", + "If the deactivation is followed through with, service management needs to finish deactivation. Commit is a reason to put the container in a DELETED state." ], "type": "string" } diff --git a/appengine/v1beta/appengine-gen.go b/appengine/v1beta/appengine-gen.go index 6e5b929e437..0d53dbfaefa 100644 --- a/appengine/v1beta/appengine-gen.go +++ b/appengine/v1beta/appengine-gen.go @@ -176,7 +176,6 @@ func NewAppsService(s *APIService) *AppsService { rs.Firewall = NewAppsFirewallService(s) rs.Locations = NewAppsLocationsService(s) rs.Operations = NewAppsOperationsService(s) - rs.Runtimes = NewAppsRuntimesService(s) rs.Services = NewAppsServicesService(s) return rs } @@ -196,8 +195,6 @@ type AppsService struct { Operations *AppsOperationsService - Runtimes *AppsRuntimesService - Services *AppsServicesService } @@ -267,15 +264,6 @@ type AppsOperationsService struct { s *APIService } -func NewAppsRuntimesService(s *APIService) *AppsRuntimesService { - rs := &AppsRuntimesService{s: s} - return rs -} - -type AppsRuntimesService struct { - s *APIService -} - func NewAppsServicesService(s *APIService) *AppsServicesService { rs := &AppsServicesService{s: s} rs.Versions = NewAppsServicesVersionsService(s) @@ -1008,6 +996,81 @@ func (s *ContainerInfo) MarshalJSON() ([]byte, error) { return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) } +// ContainerState: ContainerState contains the externally-visible +// container state that is used to communicate the state and reasoning +// for that state to the CLH. This data is not persisted by CCFE, but is +// instead derived from CCFE's internal representation of the container +// state. +type ContainerState struct { + CurrentReasons *Reasons `json:"currentReasons,omitempty"` + + // PreviousReasons: The previous and current reasons for a container + // state will be sent for a container event. CLHs that need to know the + // signal that caused the container event to trigger (edges) as opposed + // to just knowing the state can act upon differences in the previous + // and current reasons.Reasons will be provided for every system: + // service management, data governance, abuse, and billing.If this is a + // CCFE-triggered event used for reconciliation then the current reasons + // will be set to their *_CONTROL_PLANE_SYNC state. The previous reasons + // will contain the last known set of non-unknown non-control_plane_sync + // reasons for the state.Reasons fields are deprecated. New tenants + // should only use the state field. If you must know the reason(s) + // behind a specific state, please consult with CCFE team first + // (cloud-ccfe-discuss@google.com). + PreviousReasons *Reasons `json:"previousReasons,omitempty"` + + // State: The current state of the container. This state is the + // culmination of all of the opinions from external systems that CCFE + // knows about of the container. + // + // Possible values: + // "UNKNOWN_STATE" - A container should never be in an unknown state. + // Receipt of a container with this state is an error. + // "ON" - CCFE considers the container to be serving or transitioning + // into serving. + // "OFF" - CCFE considers the container to be in an OFF state. This + // could occur due to various factors. The state could be triggered by + // Google-internal audits (ex. abuse suspension, billing closed) or + // cleanups trigged by compliance systems (ex. data governance hide). + // User-initiated events such as service management deactivation trigger + // a container to an OFF state.CLHs might choose to do nothing in this + // case or to turn off costly resources. CLHs need to consider the + // customer experience if an ON/OFF/ON sequence of state transitions + // occurs vs. the cost of deleting resources, keeping metadata about + // resources, or even keeping resources live for a period of time.CCFE + // will not send any new customer requests to the CLH when the container + // is in an OFF state. However, CCFE will allow all previous customer + // requests relayed to CLH to complete. + // "DELETED" - This state indicates that the container has been (or is + // being) completely removed. This is often due to a data governance + // purge request and therefore resources should be deleted when this + // state is reached. + State string `json:"state,omitempty"` + + // ForceSendFields is a list of field names (e.g. "CurrentReasons") to + // unconditionally include in API requests. By default, fields with + // empty or default values are omitted from API requests. However, any + // non-pointer, non-interface field appearing in ForceSendFields will be + // sent to the server regardless of whether the field is empty or not. + // This may be used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` + + // NullFields is a list of field names (e.g. "CurrentReasons") to + // include in API requests with the JSON null value. By default, fields + // with empty values are omitted from API requests. However, any field + // with an empty value appearing in NullFields will be sent to the + // server as null. It is an error if a field in this list has a + // non-empty value. This may be used to include null fields in Patch + // requests. + NullFields []string `json:"-"` +} + +func (s *ContainerState) MarshalJSON() ([]byte, error) { + type NoMethod ContainerState + raw := NoMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) +} + // CpuUtilization: Target scaling by CPU usage. type CpuUtilization struct { // AggregationWindowLength: Period of time over which CPU utilization is @@ -3054,7 +3117,7 @@ type ProjectEvent struct { ProjectMetadata *ProjectsMetadata `json:"projectMetadata,omitempty"` // State: The state of the project that led to this event. - State *ProjectState `json:"state,omitempty"` + State *ContainerState `json:"state,omitempty"` // ForceSendFields is a list of field names (e.g. "EventId") to // unconditionally include in API requests. By default, fields with @@ -3079,80 +3142,6 @@ func (s *ProjectEvent) MarshalJSON() ([]byte, error) { return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) } -// ProjectState: ProjectState contains the externally-visible project -// state that is used to communicate the state and reasoning for that -// state to the CLH. This data is not persisted by CCFE, but is instead -// derived from CCFE's internal representation of the project state. -type ProjectState struct { - CurrentReasons *Reasons `json:"currentReasons,omitempty"` - - // PreviousReasons: The previous and current reasons for a project state - // will be sent for a project event. CLHs that need to know the signal - // that caused the project event to trigger (edges) as opposed to just - // knowing the state can act upon differences in the previous and - // current reasons.Reasons will be provided for every system: service - // management, data governance, abuse, and billing.If this is a - // CCFE-triggered event used for reconciliation then the current reasons - // will be set to their *_CONTROL_PLANE_SYNC state. The previous reasons - // will contain the last known set of non-unknown non-control_plane_sync - // reasons for the state.Reasons fields are deprecated. New tenants - // should only use the state field. If you must know the reason(s) - // behind a specific state, please consult with CCFE team first - // (cloud-ccfe-discuss@google.com). - PreviousReasons *Reasons `json:"previousReasons,omitempty"` - - // State: The current state of the project. This state is the - // culmination of all of the opinions from external systems that CCFE - // knows about of the project. - // - // Possible values: - // "UNKNOWN_STATE" - A project should never be in an unknown state. - // Receipt of a project with this state is an error. - // "ON" - CCFE considers the project to be serving or transitioning - // into serving. - // "OFF" - CCFE considers the project to be in an OFF state. This - // could occur due to various factors. The state could be triggered by - // Google-internal audits (ex. abuse suspension, billing closed) or - // cleanups trigged by compliance systems (ex. data governance hide). - // User-initiated events such as service management deactivation trigger - // a project to an OFF state.CLHs might choose to do nothing in this - // case or to turn off costly resources. CLHs need to consider the - // customer experience if an ON/OFF/ON sequence of state transitions - // occurs vs. the cost of deleting resources, keeping metadata about - // resources, or even keeping resources live for a period of time.CCFE - // will not send any new customer requests to the CLH when the project - // is in an OFF state. However, CCFE will allow all previous customer - // requests relayed to CLH to complete. - // "DELETED" - This state indicates that the project has been (or is - // being) completely removed. This is often due to a data governance - // purge request and therefore resources should be deleted when this - // state is reached. - State string `json:"state,omitempty"` - - // ForceSendFields is a list of field names (e.g. "CurrentReasons") to - // unconditionally include in API requests. By default, fields with - // empty or default values are omitted from API requests. However, any - // non-pointer, non-interface field appearing in ForceSendFields will be - // sent to the server regardless of whether the field is empty or not. - // This may be used to include empty fields in Patch requests. - ForceSendFields []string `json:"-"` - - // NullFields is a list of field names (e.g. "CurrentReasons") to - // include in API requests with the JSON null value. By default, fields - // with empty values are omitted from API requests. However, any field - // with an empty value appearing in NullFields will be sent to the - // server as null. It is an error if a field in this list has a - // non-empty value. This may be used to include null fields in Patch - // requests. - NullFields []string `json:"-"` -} - -func (s *ProjectState) MarshalJSON() ([]byte, error) { - type NoMethod ProjectState - raw := NoMethod(*s) - return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) -} - // ProjectsMetadata: ProjectsMetadata is the metadata CCFE stores about // the all the relevant projects (tenant, consumer, producer). type ProjectsMetadata struct { @@ -3168,24 +3157,24 @@ type ProjectsMetadata struct { // proto when communicated to CLH in the side channel. // // Possible values: - // "UNKNOWN_STATE" - A project should never be in an unknown state. - // Receipt of a project with this state is an error. - // "ON" - CCFE considers the project to be serving or transitioning + // "UNKNOWN_STATE" - A container should never be in an unknown state. + // Receipt of a container with this state is an error. + // "ON" - CCFE considers the container to be serving or transitioning // into serving. - // "OFF" - CCFE considers the project to be in an OFF state. This + // "OFF" - CCFE considers the container to be in an OFF state. This // could occur due to various factors. The state could be triggered by // Google-internal audits (ex. abuse suspension, billing closed) or // cleanups trigged by compliance systems (ex. data governance hide). // User-initiated events such as service management deactivation trigger - // a project to an OFF state.CLHs might choose to do nothing in this + // a container to an OFF state.CLHs might choose to do nothing in this // case or to turn off costly resources. CLHs need to consider the // customer experience if an ON/OFF/ON sequence of state transitions // occurs vs. the cost of deleting resources, keeping metadata about // resources, or even keeping resources live for a period of time.CCFE - // will not send any new customer requests to the CLH when the project + // will not send any new customer requests to the CLH when the container // is in an OFF state. However, CCFE will allow all previous customer // requests relayed to CLH to complete. - // "DELETED" - This state indicates that the project has been (or is + // "DELETED" - This state indicates that the container has been (or is // being) completely removed. This is often due to a data governance // purge request and therefore resources should be deleted when this // state is reached. @@ -3285,7 +3274,7 @@ func (s *ReadinessCheck) MarshalJSON() ([]byte, error) { return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) } -// Reasons: Projects transition between and within states based on +// Reasons: Containers transition between and within states based on // reasons sent from various systems. CCFE will provide the CLH with // reasons for the current state per system.The current systems that // CCFE supports are: Service Management (Inception) Data Governance @@ -3293,57 +3282,58 @@ func (s *ReadinessCheck) MarshalJSON() ([]byte, error) { type Reasons struct { // Possible values: // "ABUSE_UNKNOWN_REASON" - An unknown reason indicates that the abuse - // system has not sent a signal for this project. + // system has not sent a signal for this container. // "ABUSE_CONTROL_PLANE_SYNC" - Due to various reasons CCFE might - // proactively restate a project state to a CLH to ensure that the CLH - // and CCFE are both aware of the project state. This reason can be tied - // to any of the states. - // "SUSPEND" - If a project is deemed abusive we receive a suspend - // signal. Suspend is a reason to put the project into an INTERNAL_OFF + // proactively restate a container state to a CLH to ensure that the CLH + // and CCFE are both aware of the container state. This reason can be + // tied to any of the states. + // "SUSPEND" - If a container is deemed abusive we receive a suspend + // signal. Suspend is a reason to put the container into an INTERNAL_OFF + // state. + // "REINSTATE" - Containers that were once considered abusive can + // later be deemed non-abusive. When this happens we must reinstate the + // container. Reinstate is a reason to put the container into an ON // state. - // "REINSTATE" - Projects that were once considered abusive can later - // be deemed non-abusive. When this happens we must reinstate the - // project. Reinstate is a reason to put the project into an ON state. Abuse string `json:"abuse,omitempty"` // Possible values: // "BILLING_UNKNOWN_REASON" - An unknown reason indicates that the - // billing system has not sent a signal for this project. + // billing system has not sent a signal for this container. // "BILLING_CONTROL_PLANE_SYNC" - Due to various reasons CCFE might - // proactively restate a project state to a CLH to ensure that the CLH - // and CCFE are both aware of the project state. This reason can be tied - // to any of the states. + // proactively restate a container state to a CLH to ensure that the CLH + // and CCFE are both aware of the container state. This reason can be + // tied to any of the states. // "PROBATION" - Minor infractions cause a probation signal to be - // sent. Probation is a reason to put the project into a ON state even + // sent. Probation is a reason to put the container into a ON state even // though it is a negative signal. CCFE will block mutations for this - // project while it is on billing probation, but the CLH is expected to - // serve non-mutation requests. + // container while it is on billing probation, but the CLH is expected + // to serve non-mutation requests. // "CLOSE" - When a billing account is closed, it is a stronger signal - // about non-payment. Close is a reason to put the project into an + // about non-payment. Close is a reason to put the container into an // INTERNAL_OFF state. // "OPEN" - Consumers can re-open billing accounts and update accounts // to pull them out of probation. When this happens, we get a signal - // that the account is open. Open is a reason to put the project into an - // ON state. + // that the account is open. Open is a reason to put the container into + // an ON state. Billing string `json:"billing,omitempty"` // Possible values: // "DATA_GOVERNANCE_UNKNOWN_REASON" - An unknown reason indicates that - // data governance has not sent a signal for this project. + // data governance has not sent a signal for this container. // "DATA_GOVERNANCE_CONTROL_PLANE_SYNC" - Due to various reasons CCFE - // might proactively restate a project state to a CLH to ensure that the - // CLH and CCFE are both aware of the project state. This reason can be - // tied to any of the states. - // "HIDE" - When a project is deleted we retain some data for a period - // of time to allow the consumer to change their mind. Data governance - // sends a signal to hide the data when this occurs. Hide is a reason to - // put the project in an INTERNAL_OFF state. - // "UNHIDE" - The decision to un-delete a project can be made. When + // might proactively restate a container state to a CLH to ensure that + // the CLH and CCFE are both aware of the container state. This reason + // can be tied to any of the states. + // "HIDE" - When a container is deleted we retain some data for a + // period of time to allow the consumer to change their mind. Data + // governance sends a signal to hide the data when this occurs. Hide is + // a reason to put the container in an INTERNAL_OFF state. + // "UNHIDE" - The decision to un-delete a container can be made. When // this happens data governance tells us to unhide any hidden data. - // Unhide is a reason to put the project in an ON state. + // Unhide is a reason to put the container in an ON state. // "PURGE" - After a period of time data must be completely removed // from our systems. When data governance sends a purge signal we need - // to remove data. Purge is a reason to put the project in a DELETED + // to remove data. Purge is a reason to put the container in a DELETED // state. Purge is the only event that triggers a delete mutation. All // other events have update semantics. DataGovernance string `json:"dataGovernance,omitempty"` @@ -3351,24 +3341,24 @@ type Reasons struct { // Possible values: // "SERVICE_MANAGEMENT_UNKNOWN_REASON" - An unknown reason indicates // that we have not received a signal from service management about this - // project. Since projects are created by request of service management, - // this reason should never be set. + // container. Since containers are created by request of service + // management, this reason should never be set. // "SERVICE_MANAGEMENT_CONTROL_PLANE_SYNC" - Due to various reasons - // CCFE might proactively restate a project state to a CLH to ensure - // that the CLH and CCFE are both aware of the project state. This + // CCFE might proactively restate a container state to a CLH to ensure + // that the CLH and CCFE are both aware of the container state. This // reason can be tied to any of the states. // "ACTIVATION" - When a customer activates an API CCFE notifies the - // CLH and sets the project to the ON state. + // CLH and sets the container to the ON state. // "PREPARE_DEACTIVATION" - When a customer deactivates and API // service management starts a two-step process to perform the // deactivation. The first step is to prepare. Prepare is a reason to - // put the project in a EXTERNAL_OFF state. + // put the container in a EXTERNAL_OFF state. // "ABORT_DEACTIVATION" - If the deactivation is cancelled, service // managed needs to abort the deactivation. Abort is a reason to put the - // project in an ON state. + // container in an ON state. // "COMMIT_DEACTIVATION" - If the deactivation is followed through // with, service management needs to finish deactivation. Commit is a - // reason to put the project in a DELETED state. + // reason to put the container in a DELETED state. ServiceManagement string `json:"serviceManagement,omitempty"` // ForceSendFields is a list of field names (e.g. "Abuse") to @@ -4805,6 +4795,182 @@ func (c *AppsGetCall) Do(opts ...googleapi.CallOption) (*Application, error) { } +// method id "appengine.apps.listRuntimes": + +type AppsListRuntimesCall struct { + s *APIService + appsId string + urlParams_ gensupport.URLParams + ifNoneMatch_ string + ctx_ context.Context + header_ http.Header +} + +// ListRuntimes: Lists all the available runtimes for the application. +// +// - appsId: Part of `parent`. Name of the parent Application resource. +// Example: apps/myapp. +func (r *AppsService) ListRuntimes(appsId string) *AppsListRuntimesCall { + c := &AppsListRuntimesCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.appsId = appsId + return c +} + +// Environment sets the optional parameter "environment": The +// environment of the Application. +// +// Possible values: +// +// "ENVIRONMENT_UNSPECIFIED" - Default value. +// "STANDARD" - App Engine Standard. +// "FLEXIBLE" - App Engine Flexible +func (c *AppsListRuntimesCall) Environment(environment string) *AppsListRuntimesCall { + c.urlParams_.Set("environment", environment) + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *AppsListRuntimesCall) Fields(s ...googleapi.Field) *AppsListRuntimesCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// IfNoneMatch sets the optional parameter which makes the operation +// fail if the object's ETag matches the given value. This is useful for +// getting updates only after the object has changed since the last +// request. Use googleapi.IsNotModified to check whether the response +// error from Do is the result of In-None-Match. +func (c *AppsListRuntimesCall) IfNoneMatch(entityTag string) *AppsListRuntimesCall { + c.ifNoneMatch_ = entityTag + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *AppsListRuntimesCall) Context(ctx context.Context) *AppsListRuntimesCall { + c.ctx_ = ctx + return c +} + +// Header returns an http.Header that can be modified by the caller to +// add HTTP headers to the request. +func (c *AppsListRuntimesCall) Header() http.Header { + if c.header_ == nil { + c.header_ = make(http.Header) + } + return c.header_ +} + +func (c *AppsListRuntimesCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version) + for k, v := range c.header_ { + reqHeaders[k] = v + } + reqHeaders.Set("User-Agent", c.s.userAgent()) + if c.ifNoneMatch_ != "" { + reqHeaders.Set("If-None-Match", c.ifNoneMatch_) + } + var body io.Reader = nil + c.urlParams_.Set("alt", alt) + c.urlParams_.Set("prettyPrint", "false") + urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta/apps/{appsId}:listRuntimes") + urls += "?" + c.urlParams_.Encode() + req, err := http.NewRequest("GET", urls, body) + if err != nil { + return nil, err + } + req.Header = reqHeaders + googleapi.Expand(req.URL, map[string]string{ + "appsId": c.appsId, + }) + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "appengine.apps.listRuntimes" call. +// Exactly one of *ListRuntimesResponse or error will be non-nil. Any +// non-2xx status code is an error. Response headers are in either +// *ListRuntimesResponse.ServerResponse.Header or (if a response was +// returned at all) in error.(*googleapi.Error).Header. Use +// googleapi.IsNotModified to check whether the returned error was +// because http.StatusNotModified was returned. +func (c *AppsListRuntimesCall) Do(opts ...googleapi.CallOption) (*ListRuntimesResponse, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, gensupport.WrapError(&googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + }) + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, gensupport.WrapError(err) + } + ret := &ListRuntimesResponse{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := gensupport.DecodeResponse(target, res); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Lists all the available runtimes for the application.", + // "flatPath": "v1beta/apps/{appsId}:listRuntimes", + // "httpMethod": "GET", + // "id": "appengine.apps.listRuntimes", + // "parameterOrder": [ + // "appsId" + // ], + // "parameters": { + // "appsId": { + // "description": "Part of `parent`. Required. Name of the parent Application resource. Example: apps/myapp.", + // "location": "path", + // "required": true, + // "type": "string" + // }, + // "environment": { + // "description": "Optional. The environment of the Application.", + // "enum": [ + // "ENVIRONMENT_UNSPECIFIED", + // "STANDARD", + // "FLEXIBLE" + // ], + // "enumDescriptions": [ + // "Default value.", + // "App Engine Standard.", + // "App Engine Flexible" + // ], + // "location": "query", + // "type": "string" + // } + // }, + // "path": "v1beta/apps/{appsId}:listRuntimes", + // "response": { + // "$ref": "ListRuntimesResponse" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/appengine.admin", + // "https://www.googleapis.com/auth/cloud-platform", + // "https://www.googleapis.com/auth/cloud-platform.read-only" + // ] + // } + +} + // method id "appengine.apps.patch": type AppsPatchCall struct { @@ -8740,182 +8906,6 @@ func (c *AppsOperationsListCall) Pages(ctx context.Context, f func(*ListOperatio } } -// method id "appengine.apps.runtimes.list": - -type AppsRuntimesListCall struct { - s *APIService - appsId string - urlParams_ gensupport.URLParams - ifNoneMatch_ string - ctx_ context.Context - header_ http.Header -} - -// List: Lists all the available runtimes for the application. -// -// - appsId: Part of `parent`. Name of the parent Application resource. -// Example: apps/myapp. -func (r *AppsRuntimesService) List(appsId string) *AppsRuntimesListCall { - c := &AppsRuntimesListCall{s: r.s, urlParams_: make(gensupport.URLParams)} - c.appsId = appsId - return c -} - -// Environment sets the optional parameter "environment": The -// environment of the Application. -// -// Possible values: -// -// "ENVIRONMENT_UNSPECIFIED" - Default value. -// "STANDARD" - App Engine Standard. -// "FLEXIBLE" - App Engine Flexible -func (c *AppsRuntimesListCall) Environment(environment string) *AppsRuntimesListCall { - c.urlParams_.Set("environment", environment) - return c -} - -// Fields allows partial responses to be retrieved. See -// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse -// for more information. -func (c *AppsRuntimesListCall) Fields(s ...googleapi.Field) *AppsRuntimesListCall { - c.urlParams_.Set("fields", googleapi.CombineFields(s)) - return c -} - -// IfNoneMatch sets the optional parameter which makes the operation -// fail if the object's ETag matches the given value. This is useful for -// getting updates only after the object has changed since the last -// request. Use googleapi.IsNotModified to check whether the response -// error from Do is the result of In-None-Match. -func (c *AppsRuntimesListCall) IfNoneMatch(entityTag string) *AppsRuntimesListCall { - c.ifNoneMatch_ = entityTag - return c -} - -// Context sets the context to be used in this call's Do method. Any -// pending HTTP request will be aborted if the provided context is -// canceled. -func (c *AppsRuntimesListCall) Context(ctx context.Context) *AppsRuntimesListCall { - c.ctx_ = ctx - return c -} - -// Header returns an http.Header that can be modified by the caller to -// add HTTP headers to the request. -func (c *AppsRuntimesListCall) Header() http.Header { - if c.header_ == nil { - c.header_ = make(http.Header) - } - return c.header_ -} - -func (c *AppsRuntimesListCall) doRequest(alt string) (*http.Response, error) { - reqHeaders := make(http.Header) - reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version) - for k, v := range c.header_ { - reqHeaders[k] = v - } - reqHeaders.Set("User-Agent", c.s.userAgent()) - if c.ifNoneMatch_ != "" { - reqHeaders.Set("If-None-Match", c.ifNoneMatch_) - } - var body io.Reader = nil - c.urlParams_.Set("alt", alt) - c.urlParams_.Set("prettyPrint", "false") - urls := googleapi.ResolveRelative(c.s.BasePath, "v1beta/apps/{appsId}/runtimes") - urls += "?" + c.urlParams_.Encode() - req, err := http.NewRequest("GET", urls, body) - if err != nil { - return nil, err - } - req.Header = reqHeaders - googleapi.Expand(req.URL, map[string]string{ - "appsId": c.appsId, - }) - return gensupport.SendRequest(c.ctx_, c.s.client, req) -} - -// Do executes the "appengine.apps.runtimes.list" call. -// Exactly one of *ListRuntimesResponse or error will be non-nil. Any -// non-2xx status code is an error. Response headers are in either -// *ListRuntimesResponse.ServerResponse.Header or (if a response was -// returned at all) in error.(*googleapi.Error).Header. Use -// googleapi.IsNotModified to check whether the returned error was -// because http.StatusNotModified was returned. -func (c *AppsRuntimesListCall) Do(opts ...googleapi.CallOption) (*ListRuntimesResponse, error) { - gensupport.SetOptions(c.urlParams_, opts...) - res, err := c.doRequest("json") - if res != nil && res.StatusCode == http.StatusNotModified { - if res.Body != nil { - res.Body.Close() - } - return nil, gensupport.WrapError(&googleapi.Error{ - Code: res.StatusCode, - Header: res.Header, - }) - } - if err != nil { - return nil, err - } - defer googleapi.CloseBody(res) - if err := googleapi.CheckResponse(res); err != nil { - return nil, gensupport.WrapError(err) - } - ret := &ListRuntimesResponse{ - ServerResponse: googleapi.ServerResponse{ - Header: res.Header, - HTTPStatusCode: res.StatusCode, - }, - } - target := &ret - if err := gensupport.DecodeResponse(target, res); err != nil { - return nil, err - } - return ret, nil - // { - // "description": "Lists all the available runtimes for the application.", - // "flatPath": "v1beta/apps/{appsId}/runtimes", - // "httpMethod": "GET", - // "id": "appengine.apps.runtimes.list", - // "parameterOrder": [ - // "appsId" - // ], - // "parameters": { - // "appsId": { - // "description": "Part of `parent`. Required. Name of the parent Application resource. Example: apps/myapp.", - // "location": "path", - // "required": true, - // "type": "string" - // }, - // "environment": { - // "description": "Optional. The environment of the Application.", - // "enum": [ - // "ENVIRONMENT_UNSPECIFIED", - // "STANDARD", - // "FLEXIBLE" - // ], - // "enumDescriptions": [ - // "Default value.", - // "App Engine Standard.", - // "App Engine Flexible" - // ], - // "location": "query", - // "type": "string" - // } - // }, - // "path": "v1beta/apps/{appsId}/runtimes", - // "response": { - // "$ref": "ListRuntimesResponse" - // }, - // "scopes": [ - // "https://www.googleapis.com/auth/appengine.admin", - // "https://www.googleapis.com/auth/cloud-platform", - // "https://www.googleapis.com/auth/cloud-platform.read-only" - // ] - // } - -} - // method id "appengine.apps.services.delete": type AppsServicesDeleteCall struct { diff --git a/chromepolicy/v1/chromepolicy-api.json b/chromepolicy/v1/chromepolicy-api.json index 6e72a290f0b..f229abcc116 100644 --- a/chromepolicy/v1/chromepolicy-api.json +++ b/chromepolicy/v1/chromepolicy-api.json @@ -557,7 +557,7 @@ } } }, - "revision": "20231004", + "revision": "20231011", "rootUrl": "https://chromepolicy.googleapis.com/", "schemas": { "GoogleChromePolicyVersionsV1AdditionalTargetKeyName": { @@ -1605,13 +1605,13 @@ "label": { "enum": [ "LABEL_OPTIONAL", - "LABEL_REQUIRED", - "LABEL_REPEATED" + "LABEL_REPEATED", + "LABEL_REQUIRED" ], "enumDescriptions": [ "0 is reserved for errors", "", - "" + "The required label is only allowed in proto2. In proto3 and Editions it's explicitly prohibited. In Editions, the `field_presence` feature can be used to get this behavior." ], "type": "string" }, @@ -1663,7 +1663,7 @@ "", "", "", - "Tag-delimited aggregate. Group type is deprecated and not supported in proto3. However, Proto3 implementations should still be able to parse the group wire format and treat group fields as unknown fields.", + "Tag-delimited aggregate. Group type is deprecated and not supported after proto2. However, Proto3 implementations should still be able to parse the group wire format and treat group fields as unknown fields. In Editions, the group wire format can be enabled via the `message_encoding` feature.", "Length-delimited aggregate.", "New in version 2.", "", diff --git a/chromepolicy/v1/chromepolicy-gen.go b/chromepolicy/v1/chromepolicy-gen.go index b5bfe0a042d..8c2131e85c6 100644 --- a/chromepolicy/v1/chromepolicy-gen.go +++ b/chromepolicy/v1/chromepolicy-gen.go @@ -2080,8 +2080,10 @@ type Proto2FieldDescriptorProto struct { // Possible values: // "LABEL_OPTIONAL" - 0 is reserved for errors - // "LABEL_REQUIRED" // "LABEL_REPEATED" + // "LABEL_REQUIRED" - The required label is only allowed in proto2. In + // proto3 and Editions it's explicitly prohibited. In Editions, the + // `field_presence` feature can be used to get this behavior. Label string `json:"label,omitempty"` Name string `json:"name,omitempty"` @@ -2130,9 +2132,10 @@ type Proto2FieldDescriptorProto struct { // "TYPE_BOOL" // "TYPE_STRING" // "TYPE_GROUP" - Tag-delimited aggregate. Group type is deprecated - // and not supported in proto3. However, Proto3 implementations should - // still be able to parse the group wire format and treat group fields - // as unknown fields. + // and not supported after proto2. However, Proto3 implementations + // should still be able to parse the group wire format and treat group + // fields as unknown fields. In Editions, the group wire format can be + // enabled via the `message_encoding` feature. // "TYPE_MESSAGE" - Length-delimited aggregate. // "TYPE_BYTES" - New in version 2. // "TYPE_UINT32" diff --git a/compute/v0.beta/compute-api.json b/compute/v0.beta/compute-api.json index 86c82366737..d908dae077a 100644 --- a/compute/v0.beta/compute-api.json +++ b/compute/v0.beta/compute-api.json @@ -40049,7 +40049,7 @@ } } }, - "revision": "20230923", + "revision": "20231003", "rootUrl": "https://compute.googleapis.com/", "schemas": { "AWSV4Signature": { @@ -61400,7 +61400,7 @@ "description": "[Output Only] Information about the last attempt to create or delete the instance." }, "name": { - "description": "[Output Only] The name of the instance. The name will always exist even if the instance has not yet been created.", + "description": "[Output Only] The name of the instance. The name always exists even if the instance has not yet been created.", "type": "string" }, "preservedStateFromConfig": { @@ -62069,6 +62069,10 @@ "description": "The IPv4 address assigned to the producer instance network interface. This value will be a range in case of Serverless.", "type": "string" }, + "ipv6Address": { + "description": "The IPv6 address assigned to the producer instance network interface. This is only assigned when the stack types of both the instance network interface and the consumer subnet are IPv4_IPv6.", + "type": "string" + }, "projectIdOrNum": { "description": "The project id or number of the interface to which the IP was assigned.", "type": "string" @@ -62103,6 +62107,10 @@ "subnetwork": { "description": "The subnetwork used to assign the IP to the producer instance network interface.", "type": "string" + }, + "subnetworkCidrRange": { + "description": "[Output Only] The CIDR range of the subnet from which the IPv4 internal IP was allocated from.", + "type": "string" } }, "type": "object" diff --git a/compute/v0.beta/compute-gen.go b/compute/v0.beta/compute-gen.go index 02ea7d16967..2319e42e59f 100644 --- a/compute/v0.beta/compute-gen.go +++ b/compute/v0.beta/compute-gen.go @@ -32236,8 +32236,8 @@ type ManagedInstance struct { // create or delete the instance. LastAttempt *ManagedInstanceLastAttempt `json:"lastAttempt,omitempty"` - // Name: [Output Only] The name of the instance. The name will always - // exist even if the instance has not yet been created. + // Name: [Output Only] The name of the instance. The name always exists + // even if the instance has not yet been created. Name string `json:"name,omitempty"` // PreservedStateFromConfig: [Output Only] Preserved state applied from @@ -33290,6 +33290,11 @@ type NetworkAttachmentConnectedEndpoint struct { // interface. This value will be a range in case of Serverless. IpAddress string `json:"ipAddress,omitempty"` + // Ipv6Address: The IPv6 address assigned to the producer instance + // network interface. This is only assigned when the stack types of both + // the instance network interface and the consumer subnet are IPv4_IPv6. + Ipv6Address string `json:"ipv6Address,omitempty"` + // ProjectIdOrNum: The project id or number of the interface to which // the IP was assigned. ProjectIdOrNum string `json:"projectIdOrNum,omitempty"` @@ -33317,6 +33322,10 @@ type NetworkAttachmentConnectedEndpoint struct { // instance network interface. Subnetwork string `json:"subnetwork,omitempty"` + // SubnetworkCidrRange: [Output Only] The CIDR range of the subnet from + // which the IPv4 internal IP was allocated from. + SubnetworkCidrRange string `json:"subnetworkCidrRange,omitempty"` + // ForceSendFields is a list of field names (e.g. "IpAddress") to // unconditionally include in API requests. By default, fields with // empty or default values are omitted from API requests. However, any diff --git a/content/v2.1/content-api.json b/content/v2.1/content-api.json index 37f19d9f780..86fa8f51e03 100644 --- a/content/v2.1/content-api.json +++ b/content/v2.1/content-api.json @@ -5523,7 +5523,7 @@ ], "parameters": { "countryCode": { - "description": "[CLDR country code](http://www.unicode.org/repos/cldr/tags/latest/common/main/en.xml) (e.g. \"US\"), used as a filter on repricing rules.", + "description": "[CLDR country code](http://www.unicode.org/repos/cldr/tags/latest/common/main/en.xml) (for example, \"US\"), used as a filter on repricing rules.", "location": "query", "type": "string" }, @@ -5599,7 +5599,7 @@ "repricingreports": { "methods": { "list": { - "description": "Lists the metrics report for a given Repricing rule.", + "description": "*Deprecated*: New merchants can't start using this service. Lists the metrics report for a given Repricing rule.", "flatPath": "{merchantId}/repricingrules/{ruleId}/repricingreports", "httpMethod": "GET", "id": "content.repricingrules.repricingreports.list", @@ -6488,7 +6488,7 @@ } } }, - "revision": "20231003", + "revision": "20231011", "rootUrl": "https://shoppingcontent.googleapis.com/", "schemas": { "Account": { @@ -16578,7 +16578,7 @@ "type": "object" }, "RepricingRule": { - "description": "Represents a repricing rule. A repricing rule is used by shopping serving to adjust transactable offer prices if conditions are met.", + "description": "*Deprecated*: New merchants can't start using this resource. Represents a repricing rule. A repricing rule is used by shopping serving to adjust transactable offer prices if conditions are met.", "id": "RepricingRule", "properties": { "cogsBasedRule": { @@ -16586,7 +16586,7 @@ "description": "The rule definition for TYPE_COGS_BASED. Required when the rule type is TYPE_COGS_BASED." }, "countryCode": { - "description": "Required. Immutable. [CLDR country code](http://www.unicode.org/repos/cldr/tags/latest/common/main/en.xml) (e.g. \"US\").", + "description": "Required. Immutable. [CLDR country code](http://www.unicode.org/repos/cldr/tags/latest/common/main/en.xml) (for example, \"US\").", "type": "string" }, "effectiveTimePeriod": { @@ -16659,7 +16659,7 @@ "type": "integer" }, "priceDelta": { - "description": "The price delta against the COGS. E.g. 2 means $2 more of the COGS.", + "description": "The price delta against the COGS. For example, 2 means $2 more of the COGS.", "type": "string" } }, @@ -16739,7 +16739,7 @@ "id": "RepricingRuleEligibleOfferMatcherStringMatcher", "properties": { "strAttributes": { - "description": "String attributes, as long as such attribute of an offer is one of the string attribute values, the offer is considered as passing the matcher. The string matcher checks an offer for inclusivity in the string attributes, not equality. Only literal string matching is supported, no regex.", + "description": "String attributes, as long as such attribute of an offer is one of the string attribute values, the offer is considered as passing the matcher. The string matcher checks an offer for inclusivity in the string attributes, not equality. Only literal string matching is supported, no regular expressions.", "items": { "type": "string" }, @@ -17784,7 +17784,7 @@ "type": "array" }, "shipmentType": { - "description": "Type of locations this service ships orders to. Acceptable values are: - \"`delivery`\" - \"`pickup`\" - \"`local_delivery`\" ", + "description": "Type of locations this service ships orders to. Acceptable values are: - \"`delivery`\" - \"`pickup`\" - \"`local_delivery`\" - \"`collection_point`\" ", "type": "string" }, "storeConfig": { diff --git a/content/v2.1/content-gen.go b/content/v2.1/content-gen.go index 1fced13a756..93560219727 100644 --- a/content/v2.1/content-gen.go +++ b/content/v2.1/content-gen.go @@ -17516,8 +17516,9 @@ func (s *RepricingProductReportBuyboxWinningProductStats) MarshalJSON() ([]byte, return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) } -// RepricingRule: Represents a repricing rule. A repricing rule is used -// by shopping serving to adjust transactable offer prices if conditions +// RepricingRule: *Deprecated*: New merchants can't start using this +// resource. Represents a repricing rule. A repricing rule is used by +// shopping serving to adjust transactable offer prices if conditions // are met. type RepricingRule struct { // CogsBasedRule: The rule definition for TYPE_COGS_BASED. Required when @@ -17526,7 +17527,7 @@ type RepricingRule struct { // CountryCode: Required. Immutable. CLDR country code // (http://www.unicode.org/repos/cldr/tags/latest/common/main/en.xml) - // (e.g. "US"). + // (for example, "US"). CountryCode string `json:"countryCode,omitempty"` // EffectiveTimePeriod: Required. Time period when the rule should take @@ -17619,8 +17620,8 @@ type RepricingRuleCostOfGoodsSaleRule struct { // mean to set the adjusted price 1.2X of the COGS data. PercentageDelta int64 `json:"percentageDelta,omitempty"` - // PriceDelta: The price delta against the COGS. E.g. 2 means $2 more of - // the COGS. + // PriceDelta: The price delta against the COGS. For example, 2 means $2 + // more of the COGS. PriceDelta string `json:"priceDelta,omitempty"` // ForceSendFields is a list of field names (e.g. "PercentageDelta") to @@ -17776,7 +17777,7 @@ type RepricingRuleEligibleOfferMatcherStringMatcher struct { // offer is one of the string attribute values, the offer is considered // as passing the matcher. The string matcher checks an offer for // inclusivity in the string attributes, not equality. Only literal - // string matching is supported, no regex. + // string matching is supported, no regular expressions. StrAttributes []string `json:"strAttributes,omitempty"` // ForceSendFields is a list of field names (e.g. "StrAttributes") to @@ -19481,7 +19482,7 @@ type Service struct { // ShipmentType: Type of locations this service ships orders to. // Acceptable values are: - "delivery" - "pickup" - - // "local_delivery" + // "local_delivery" - "collection_point" ShipmentType string `json:"shipmentType,omitempty"` // StoreConfig: A list of stores your products are delivered from. This @@ -46095,7 +46096,7 @@ func (r *RepricingrulesService) List(merchantId int64) *RepricingrulesListCall { // CountryCode sets the optional parameter "countryCode": CLDR country // code // (http://www.unicode.org/repos/cldr/tags/latest/common/main/en.xml) -// (e.g. "US"), used as a filter on repricing rules. +// (for example, "US"), used as a filter on repricing rules. func (c *RepricingrulesListCall) CountryCode(countryCode string) *RepricingrulesListCall { c.urlParams_.Set("countryCode", countryCode) return c @@ -46236,7 +46237,7 @@ func (c *RepricingrulesListCall) Do(opts ...googleapi.CallOption) (*ListRepricin // ], // "parameters": { // "countryCode": { - // "description": "[CLDR country code](http://www.unicode.org/repos/cldr/tags/latest/common/main/en.xml) (e.g. \"US\"), used as a filter on repricing rules.", + // "description": "[CLDR country code](http://www.unicode.org/repos/cldr/tags/latest/common/main/en.xml) (for example, \"US\"), used as a filter on repricing rules.", // "location": "query", // "type": "string" // }, @@ -46466,7 +46467,8 @@ type RepricingrulesRepricingreportsListCall struct { header_ http.Header } -// List: Lists the metrics report for a given Repricing rule. +// List: *Deprecated*: New merchants can't start using this service. +// Lists the metrics report for a given Repricing rule. // // - merchantId: Id of the merchant who owns the Repricing rule. // - ruleId: Id of the Repricing rule. @@ -46614,7 +46616,7 @@ func (c *RepricingrulesRepricingreportsListCall) Do(opts ...googleapi.CallOption } return ret, nil // { - // "description": "Lists the metrics report for a given Repricing rule.", + // "description": "*Deprecated*: New merchants can't start using this service. Lists the metrics report for a given Repricing rule.", // "flatPath": "{merchantId}/repricingrules/{ruleId}/repricingreports", // "httpMethod": "GET", // "id": "content.repricingrules.repricingreports.list", diff --git a/displayvideo/v3/displayvideo-api.json b/displayvideo/v3/displayvideo-api.json index c5a9cb50a40..5794ea80bbd 100644 --- a/displayvideo/v3/displayvideo-api.json +++ b/displayvideo/v3/displayvideo-api.json @@ -9127,7 +9127,7 @@ } } }, - "revision": "20231009", + "revision": "20231012", "rootUrl": "https://displayvideo.googleapis.com/", "schemas": { "ActiveViewVideoViewabilityMetricConfig": { @@ -10139,7 +10139,7 @@ "AD_POSITION", "OPERATING_SYSTEM_ID", "MOBILE_MODEL_ID", - "EXCHANGE_ID", + "EXCHANGE", "ENVIRONMENT", "COUNTRY_ID", "CITY_ID", @@ -10153,7 +10153,7 @@ "Ad position. Value is stored in the onScreenPositionValue field of the comparison value.", "The operating system identifier. Value is stored in the int64Value field of the comparison value.", "The mobile model identifier. Value is stored in the int64Value field of the comparison value.", - "The exchange identifier. Value is stored in the int64Value field of the comparison value.", + "Exchange. Value is stored in the exchangeValue field of the comparison value.", "Serving environment. Value is stored in the environmentValue field of the comparison value.", "The country or region identifier. Value is stored in the int64Value field of the comparison value.", "The city identifier. Value is stored in the int64Value field of the comparison value.", diff --git a/displayvideo/v3/displayvideo-gen.go b/displayvideo/v3/displayvideo-gen.go index d3e93ee1f52..600b1afa9b8 100644 --- a/displayvideo/v3/displayvideo-gen.go +++ b/displayvideo/v3/displayvideo-gen.go @@ -2060,8 +2060,8 @@ type AlgorithmRulesSignal struct { // stored in the int64Value field of the comparison value. // "MOBILE_MODEL_ID" - The mobile model identifier. Value is stored in // the int64Value field of the comparison value. - // "EXCHANGE_ID" - The exchange identifier. Value is stored in the - // int64Value field of the comparison value. + // "EXCHANGE" - Exchange. Value is stored in the exchangeValue field + // of the comparison value. // "ENVIRONMENT" - Serving environment. Value is stored in the // environmentValue field of the comparison value. // "COUNTRY_ID" - The country or region identifier. Value is stored in diff --git a/dlp/v2/dlp-api.json b/dlp/v2/dlp-api.json index dae7172b457..f870e4c2710 100644 --- a/dlp/v2/dlp-api.json +++ b/dlp/v2/dlp-api.json @@ -3412,7 +3412,7 @@ } } }, - "revision": "20231001", + "revision": "20231008", "rootUrl": "https://dlp.googleapis.com/", "schemas": { "GooglePrivacyDlpV2Action": { @@ -3580,7 +3580,7 @@ "id": "GooglePrivacyDlpV2BigQueryOptions", "properties": { "excludedFields": { - "description": "References to fields excluded from scanning. This allows you to skip inspection of entire columns which you know have no findings. When inspecting a table, we recommend that you inspect all columns. Otherwise, findings might be impacted because hints from excluded columns will not be used.", + "description": "References to fields excluded from scanning. This allows you to skip inspection of entire columns which you know have no findings. When inspecting a table, we recommend that you inspect all columns. Otherwise, findings might be affected because hints from excluded columns will not be used.", "items": { "$ref": "GooglePrivacyDlpV2FieldId" }, @@ -3594,7 +3594,7 @@ "type": "array" }, "includedFields": { - "description": "Limit scanning only to these fields. When inspecting a table, we recommend that you inspect all columns. Otherwise, findings might be impacted because hints from excluded columns will not be used.", + "description": "Limit scanning only to these fields. When inspecting a table, we recommend that you inspect all columns. Otherwise, findings might be affected because hints from excluded columns will not be used.", "items": { "$ref": "GooglePrivacyDlpV2FieldId" }, @@ -5283,7 +5283,7 @@ "description": "Detailed error codes and messages." }, "timestamps": { - "description": "The times the error occurred. List includes the oldest timestamp, and the last 9 ones.", + "description": "The times the error occurred. List includes the oldest timestamp and the last 9 timestamps.", "items": { "format": "google-datetime", "type": "string" @@ -6008,7 +6008,7 @@ "type": "object" }, "GooglePrivacyDlpV2InfoTypeLikelihood": { - "description": "Configuration to control custom minimum likelihoods per infotype. Used when certain infotypes need to return with higher or lower precision than the baseline, i.e. when wanting PERSON_NAME to return all possible names without lowering the precision of other infotypes.", + "description": "Configuration for setting a minimum likelihood per infotype. Used to customize the minimum likelihood level for specific infotypes in the request. For example, use this if you want to lower the precision for PERSON_NAME without lowering the precision for the other infotypes in the request.", "id": "GooglePrivacyDlpV2InfoTypeLikelihood", "properties": { "infoType": { @@ -6016,7 +6016,7 @@ "description": "Type of information the likelihood threshold applies to. Only one likelihood per info_type should be provided. If InfoTypeLikelihood does not have an info_type, the configuration fails." }, "minLikelihood": { - "description": "Only returns findings equal or above this threshold. This field is required or else the configuration fails.", + "description": "Only returns findings equal to or above this threshold. This field is required or else the configuration fails.", "enum": [ "LIKELIHOOD_UNSPECIFIED", "VERY_UNLIKELY", @@ -6167,7 +6167,7 @@ "description": "Configuration to control the number of findings returned. This is not used for data profiling. When redacting sensitive data from images, finding limits don't apply. They can cause unexpected or inconsistent results, where only some data is redacted. Don't include finding limits in RedactImage requests. Otherwise, Cloud DLP returns an error. When set within an InspectJobConfig, the specified maximum values aren't hard limits. If an inspection job reaches these limits, the job ends gradually, not abruptly. Therefore, the actual number of findings that Cloud DLP returns can be multiple times higher than these maximum values." }, "minLikelihood": { - "description": "Only returns findings equal or above this threshold. The default is POSSIBLE. See https://cloud.google.com/dlp/docs/likelihood to learn more.", + "description": "Only returns findings equal to or above this threshold. The default is POSSIBLE. In general, the highest likelihood setting yields the fewest findings in results and the lowest chance of a false positive. For more information, see [Match likelihood](https://cloud.google.com/dlp/docs/likelihood).", "enum": [ "LIKELIHOOD_UNSPECIFIED", "VERY_UNLIKELY", @@ -6187,7 +6187,7 @@ "type": "string" }, "minLikelihoodPerInfoType": { - "description": "Per infotype likelihoods. For each infotype, a user can specify a minimum likelihood, and only return that infotype if it is above that threshold. If an infotype is not included, it uses the InspectConfig min_likelihood.", + "description": "Minimum likelihood per infotype. For each infotype, a user can specify a minimum likelihood. The system only returns a finding if its likelihood is above this threshold. If this field is not set, the system uses the InspectConfig min_likelihood.", "items": { "$ref": "GooglePrivacyDlpV2InfoTypeLikelihood" }, diff --git a/dlp/v2/dlp-gen.go b/dlp/v2/dlp-gen.go index 80ce4a60dfe..03c53b16cc2 100644 --- a/dlp/v2/dlp-gen.go +++ b/dlp/v2/dlp-gen.go @@ -763,7 +763,7 @@ type GooglePrivacyDlpV2BigQueryOptions struct { // ExcludedFields: References to fields excluded from scanning. This // allows you to skip inspection of entire columns which you know have // no findings. When inspecting a table, we recommend that you inspect - // all columns. Otherwise, findings might be impacted because hints from + // all columns. Otherwise, findings might be affected because hints from // excluded columns will not be used. ExcludedFields []*GooglePrivacyDlpV2FieldId `json:"excludedFields,omitempty"` @@ -777,7 +777,7 @@ type GooglePrivacyDlpV2BigQueryOptions struct { // IncludedFields: Limit scanning only to these fields. When inspecting // a table, we recommend that you inspect all columns. Otherwise, - // findings might be impacted because hints from excluded columns will + // findings might be affected because hints from excluded columns will // not be used. IncludedFields []*GooglePrivacyDlpV2FieldId `json:"includedFields,omitempty"` @@ -3774,7 +3774,7 @@ type GooglePrivacyDlpV2Error struct { Details *GoogleRpcStatus `json:"details,omitempty"` // Timestamps: The times the error occurred. List includes the oldest - // timestamp, and the last 9 ones. + // timestamp and the last 9 timestamps. Timestamps []string `json:"timestamps,omitempty"` // ForceSendFields is a list of field names (e.g. "Details") to @@ -4989,11 +4989,11 @@ func (s *GooglePrivacyDlpV2InfoTypeDescription) MarshalJSON() ([]byte, error) { return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) } -// GooglePrivacyDlpV2InfoTypeLikelihood: Configuration to control custom -// minimum likelihoods per infotype. Used when certain infotypes need to -// return with higher or lower precision than the baseline, i.e. when -// wanting PERSON_NAME to return all possible names without lowering the -// precision of other infotypes. +// GooglePrivacyDlpV2InfoTypeLikelihood: Configuration for setting a +// minimum likelihood per infotype. Used to customize the minimum +// likelihood level for specific infotypes in the request. For example, +// use this if you want to lower the precision for PERSON_NAME without +// lowering the precision for the other infotypes in the request. type GooglePrivacyDlpV2InfoTypeLikelihood struct { // InfoType: Type of information the likelihood threshold applies to. // Only one likelihood per info_type should be provided. If @@ -5001,8 +5001,8 @@ type GooglePrivacyDlpV2InfoTypeLikelihood struct { // fails. InfoType *GooglePrivacyDlpV2InfoType `json:"infoType,omitempty"` - // MinLikelihood: Only returns findings equal or above this threshold. - // This field is required or else the configuration fails. + // MinLikelihood: Only returns findings equal to or above this + // threshold. This field is required or else the configuration fails. // // Possible values: // "LIKELIHOOD_UNSPECIFIED" - Default value; same as POSSIBLE. @@ -5257,9 +5257,11 @@ type GooglePrivacyDlpV2InspectConfig struct { // these maximum values. Limits *GooglePrivacyDlpV2FindingLimits `json:"limits,omitempty"` - // MinLikelihood: Only returns findings equal or above this threshold. - // The default is POSSIBLE. See - // https://cloud.google.com/dlp/docs/likelihood to learn more. + // MinLikelihood: Only returns findings equal to or above this + // threshold. The default is POSSIBLE. In general, the highest + // likelihood setting yields the fewest findings in results and the + // lowest chance of a false positive. For more information, see Match + // likelihood (https://cloud.google.com/dlp/docs/likelihood). // // Possible values: // "LIKELIHOOD_UNSPECIFIED" - Default value; same as POSSIBLE. @@ -5271,10 +5273,10 @@ type GooglePrivacyDlpV2InspectConfig struct { // positive. MinLikelihood string `json:"minLikelihood,omitempty"` - // MinLikelihoodPerInfoType: Per infotype likelihoods. For each - // infotype, a user can specify a minimum likelihood, and only return - // that infotype if it is above that threshold. If an infotype is not - // included, it uses the InspectConfig min_likelihood. + // MinLikelihoodPerInfoType: Minimum likelihood per infotype. For each + // infotype, a user can specify a minimum likelihood. The system only + // returns a finding if its likelihood is above this threshold. If this + // field is not set, the system uses the InspectConfig min_likelihood. MinLikelihoodPerInfoType []*GooglePrivacyDlpV2InfoTypeLikelihood `json:"minLikelihoodPerInfoType,omitempty"` // RuleSet: Set of rules to apply to the findings for this diff --git a/run/v1/run-api.json b/run/v1/run-api.json index 9c99a6a623e..667ecd2f2b2 100644 --- a/run/v1/run-api.json +++ b/run/v1/run-api.json @@ -2289,7 +2289,7 @@ } } }, - "revision": "20231001", + "revision": "20231008", "rootUrl": "https://run.googleapis.com/", "schemas": { "Addressable": { @@ -3934,6 +3934,12 @@ }, "type": "array" }, + "desiredReplicas": { + "description": "Output only. The desired number of instances running this revision. For Cloud Run, this only includes instances provisioned using the minScale annotation. It does not include instances created by autoscaling.", + "format": "int32", + "readOnly": true, + "type": "integer" + }, "imageDigest": { "description": "ImageDigest holds the resolved digest for the image specified within .Spec.Container.Image. The digest is resolved during the creation of Revision. This field holds the digest value regardless of whether a tag or digest was originally specified in the Container object.", "type": "string" diff --git a/run/v1/run-gen.go b/run/v1/run-gen.go index 934d82ed045..1e060d689e6 100644 --- a/run/v1/run-gen.go +++ b/run/v1/run-gen.go @@ -3256,6 +3256,12 @@ type RevisionStatus struct { // receive traffic. Conditions []*GoogleCloudRunV1Condition `json:"conditions,omitempty"` + // DesiredReplicas: Output only. The desired number of instances running + // this revision. For Cloud Run, this only includes instances + // provisioned using the minScale annotation. It does not include + // instances created by autoscaling. + DesiredReplicas int64 `json:"desiredReplicas,omitempty"` + // ImageDigest: ImageDigest holds the resolved digest for the image // specified within .Spec.Container.Image. The digest is resolved during // the creation of Revision. This field holds the digest value diff --git a/travelimpactmodel/v1/travelimpactmodel-api.json b/travelimpactmodel/v1/travelimpactmodel-api.json index d84a58849d6..29eb1f3d632 100644 --- a/travelimpactmodel/v1/travelimpactmodel-api.json +++ b/travelimpactmodel/v1/travelimpactmodel-api.json @@ -116,7 +116,7 @@ } } }, - "revision": "20221031", + "revision": "20231011", "rootUrl": "https://travelimpactmodel.googleapis.com/", "schemas": { "ComputeFlightEmissionsRequest": { @@ -234,7 +234,7 @@ "properties": { "emissionsGramsPerPax": { "$ref": "EmissionsGramsPerPax", - "description": "Optional. Per-passenger emission estimate numbers. Will not be present if emissions could not be computed. For the list of reasons why emissions could not be computed, see ComputeFlightEmissions." + "description": "Optional. Per-passenger emission estimate numbers. Will not be present if emissions could not be computed. For the list of reasons why emissions could not be computed, see ComputeFlightEmissions. Note this field is currently equivalent to ttw_emissions_grams_per_pax until TIM version 1.X.0 which will update this to be total wtw emissions aka wtt_emissions_grams_per_pax + ttw_emissions_grams_per_pax." }, "flight": { "$ref": "Flight", diff --git a/travelimpactmodel/v1/travelimpactmodel-gen.go b/travelimpactmodel/v1/travelimpactmodel-gen.go index d6b11879530..30bbb369e6b 100644 --- a/travelimpactmodel/v1/travelimpactmodel-gen.go +++ b/travelimpactmodel/v1/travelimpactmodel-gen.go @@ -355,7 +355,10 @@ type FlightWithEmissions struct { // EmissionsGramsPerPax: Optional. Per-passenger emission estimate // numbers. Will not be present if emissions could not be computed. For // the list of reasons why emissions could not be computed, see - // ComputeFlightEmissions. + // ComputeFlightEmissions. Note this field is currently equivalent to + // ttw_emissions_grams_per_pax until TIM version 1.X.0 which will update + // this to be total wtw emissions aka wtt_emissions_grams_per_pax + + // ttw_emissions_grams_per_pax. EmissionsGramsPerPax *EmissionsGramsPerPax `json:"emissionsGramsPerPax,omitempty"` // Flight: Required. Matches the flight identifiers in the request. diff --git a/youtube/v3/youtube-api.json b/youtube/v3/youtube-api.json index 02d66bfebc1..82a32410854 100644 --- a/youtube/v3/youtube-api.json +++ b/youtube/v3/youtube-api.json @@ -717,11 +717,6 @@ "location": "query", "type": "string" }, - "forHandle": { - "description": "Return the channel associated with a YouTube handle. UNIMPLEMENTED.", - "location": "query", - "type": "string" - }, "forUsername": { "description": "Return the channel associated with a YouTube username.", "location": "query", @@ -2171,6 +2166,158 @@ } } }, + "playlistImages": { + "methods": { + "delete": { + "description": "Deletes a resource.", + "flatPath": "youtube/v3/playlistImages", + "httpMethod": "DELETE", + "id": "youtube.playlistImages.delete", + "parameterOrder": [], + "parameters": { + "id": { + "description": "Id to identify this image. This is returned from by the List method.", + "location": "query", + "type": "string" + }, + "onBehalfOfContentOwner": { + "description": "*Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwner* parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner.", + "location": "query", + "type": "string" + } + }, + "path": "youtube/v3/playlistImages", + "scopes": [ + "https://www.googleapis.com/auth/youtube", + "https://www.googleapis.com/auth/youtube.force-ssl", + "https://www.googleapis.com/auth/youtubepartner" + ] + }, + "insert": { + "description": "Inserts a new resource into this collection.", + "flatPath": "youtube/v3/playlistImages", + "httpMethod": "POST", + "id": "youtube.playlistImages.insert", + "parameterOrder": [], + "parameters": { + "onBehalfOfContentOwner": { + "description": "*Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwner* parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner.", + "location": "query", + "type": "string" + }, + "onBehalfOfContentOwnerChannel": { + "description": "This parameter can only be used in a properly authorized request. *Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwnerChannel* parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel.", + "location": "query", + "type": "string" + }, + "part": { + "description": "The *part* parameter specifies the properties that the API response will include.", + "location": "query", + "repeated": true, + "type": "string" + } + }, + "path": "youtube/v3/playlistImages", + "request": { + "$ref": "PlaylistImage" + }, + "response": { + "$ref": "PlaylistImage" + }, + "scopes": [ + "https://www.googleapis.com/auth/youtube", + "https://www.googleapis.com/auth/youtube.force-ssl", + "https://www.googleapis.com/auth/youtubepartner" + ] + }, + "list": { + "description": "Retrieves a list of resources, possibly filtered.", + "flatPath": "youtube/v3/playlistImages", + "httpMethod": "GET", + "id": "youtube.playlistImages.list", + "parameterOrder": [], + "parameters": { + "maxResults": { + "default": "5", + "description": "The *maxResults* parameter specifies the maximum number of items that should be returned in the result set.", + "format": "uint32", + "location": "query", + "maximum": "50", + "minimum": "0", + "type": "integer" + }, + "onBehalfOfContentOwner": { + "description": "*Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwner* parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner.", + "location": "query", + "type": "string" + }, + "onBehalfOfContentOwnerChannel": { + "description": "This parameter can only be used in a properly authorized request. *Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwnerChannel* parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel.", + "location": "query", + "type": "string" + }, + "pageToken": { + "description": "The *pageToken* parameter identifies a specific page in the result set that should be returned. In an API response, the nextPageToken and prevPageToken properties identify other pages that could be retrieved.", + "location": "query", + "type": "string" + }, + "parent": { + "description": "Return PlaylistImages for this playlist id.", + "location": "query", + "type": "string" + }, + "part": { + "description": "The *part* parameter specifies a comma-separated list of one or more playlistImage resource properties that the API response will include. If the parameter identifies a property that contains child properties, the child properties will be included in the response.", + "location": "query", + "repeated": true, + "type": "string" + } + }, + "path": "youtube/v3/playlistImages", + "response": { + "$ref": "PlaylistImageListResponse" + }, + "scopes": [ + "https://www.googleapis.com/auth/youtube", + "https://www.googleapis.com/auth/youtube.force-ssl", + "https://www.googleapis.com/auth/youtube.readonly", + "https://www.googleapis.com/auth/youtubepartner" + ] + }, + "update": { + "description": "Updates an existing resource.", + "flatPath": "youtube/v3/playlistImages", + "httpMethod": "PUT", + "id": "youtube.playlistImages.update", + "parameterOrder": [], + "parameters": { + "onBehalfOfContentOwner": { + "description": "*Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwner* parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner.", + "location": "query", + "type": "string" + }, + "part": { + "description": "The *part* parameter specifies the properties that the API response will include.", + "location": "query", + "repeated": true, + "type": "string" + } + }, + "path": "youtube/v3/playlistImages", + "request": { + "$ref": "PlaylistImage" + }, + "response": { + "$ref": "PlaylistImage" + }, + "scopes": [ + "https://www.googleapis.com/auth/youtube", + "https://www.googleapis.com/auth/youtube.force-ssl", + "https://www.googleapis.com/auth/youtubepartner" + ] + } + } + }, "playlistItems": { "methods": { "delete": { @@ -2658,11 +2805,6 @@ "location": "query", "type": "string" }, - "relatedToVideoId": { - "description": "Search related to a resource.", - "location": "query", - "type": "string" - }, "relevanceLanguage": { "description": "Return results relevant to this language.", "location": "query", @@ -3852,7 +3994,7 @@ } } }, - "revision": "20231008", + "revision": "20231011", "rootUrl": "https://youtube.googleapis.com/", "schemas": { "AbuseReport": { @@ -9544,6 +9686,84 @@ }, "type": "object" }, + "PlaylistImage": { + "id": "PlaylistImage", + "properties": { + "id": { + "description": "Identifies this resource (playlist id and image type).", + "type": "string" + }, + "kind": { + "default": "youtube#playlistImage", + "description": "Identifies what kind of resource this is. Value: the fixed string \"youtube#playlistImages\".", + "type": "string" + }, + "snippet": { + "$ref": "PlaylistImageSnippet" + } + }, + "type": "object" + }, + "PlaylistImageListResponse": { + "id": "PlaylistImageListResponse", + "properties": { + "items": { + "items": { + "$ref": "PlaylistImage" + }, + "type": "array" + }, + "kind": { + "default": "youtube#PlaylistImageListResponse", + "description": "Identifies what kind of resource this is. Value: the fixed string \"youtube#playlistImageListResponse\".", + "type": "string" + }, + "nextPageToken": { + "description": "The token that can be used as the value of the pageToken parameter to retrieve the next page in the result set.", + "type": "string" + }, + "pageInfo": { + "$ref": "PageInfo", + "description": "General pagination information." + }, + "prevPageToken": { + "description": "The token that can be used as the value of the pageToken parameter to retrieve the previous page in the result set.", + "type": "string" + } + }, + "type": "object" + }, + "PlaylistImageSnippet": { + "description": "A *playlistImage* resource identifies another resource, such as a image, that is associated with a playlist. In addition, the playlistImage resource contains details about the included resource that pertain specifically to how that resource is used in that playlist. YouTube uses playlists to identify special collections of videos for a channel, such as: - uploaded videos - favorite videos - positively rated (liked) videos - watch history To be more specific, these lists are associated with a channel, which is a collection of a person, group, or company's videos, playlists, and other YouTube information. You can retrieve the playlist IDs for each of these lists from the channel resource for a given channel. You can then use the playlistImages.list method to retrieve image data for any of those playlists. You can also add or remove images from those lists by calling the playlistImages.insert and playlistImages.delete methods.", + "id": "PlaylistImageSnippet", + "properties": { + "height": { + "description": "The image height.", + "format": "int32", + "type": "integer" + }, + "playlistId": { + "description": "The Playlist ID of the playlist this image is associated with.", + "type": "string" + }, + "type": { + "description": "The image type.", + "enum": [ + "hero" + ], + "enumDescriptions": [ + "The main image that will be used for this playlist." + ], + "type": "string" + }, + "width": { + "description": "The image width.", + "format": "int32", + "type": "integer" + } + }, + "type": "object" + }, "PlaylistItem": { "description": "A *playlistItem* resource identifies another resource, such as a video, that is included in a playlist. In addition, the playlistItem resource contains details about the included resource that pertain specifically to how that resource is used in that playlist. YouTube uses playlists to identify special collections of videos for a channel, such as: - uploaded videos - favorite videos - positively rated (liked) videos - watch history - watch later To be more specific, these lists are associated with a channel, which is a collection of a person, group, or company's videos, playlists, and other YouTube information. You can retrieve the playlist IDs for each of these lists from the channel resource for a given channel. You can then use the playlistItems.list method to retrieve any of those lists. You can also add or remove items from those lists by calling the playlistItems.insert and playlistItems.delete methods. For example, if a user gives a positive rating to a video, you would insert that video into the liked videos playlist for that user's channel.", "id": "PlaylistItem", diff --git a/youtube/v3/youtube-gen.go b/youtube/v3/youtube-gen.go index 4cc6d60657b..eb38863ed82 100644 --- a/youtube/v3/youtube-gen.go +++ b/youtube/v3/youtube-gen.go @@ -180,6 +180,7 @@ func New(client *http.Client) (*Service, error) { s.LiveStreams = NewLiveStreamsService(s) s.Members = NewMembersService(s) s.MembershipsLevels = NewMembershipsLevelsService(s) + s.PlaylistImages = NewPlaylistImagesService(s) s.PlaylistItems = NewPlaylistItemsService(s) s.Playlists = NewPlaylistsService(s) s.Search = NewSearchService(s) @@ -235,6 +236,8 @@ type Service struct { MembershipsLevels *MembershipsLevelsService + PlaylistImages *PlaylistImagesService + PlaylistItems *PlaylistItemsService Playlists *PlaylistsService @@ -422,6 +425,15 @@ type MembershipsLevelsService struct { s *Service } +func NewPlaylistImagesService(s *Service) *PlaylistImagesService { + rs := &PlaylistImagesService{s: s} + return rs +} + +type PlaylistImagesService struct { + s *Service +} + func NewPlaylistItemsService(s *Service) *PlaylistItemsService { rs := &PlaylistItemsService{s: s} return rs @@ -7221,6 +7233,143 @@ func (s *PlaylistContentDetails) MarshalJSON() ([]byte, error) { return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) } +type PlaylistImage struct { + // Id: Identifies this resource (playlist id and image type). + Id string `json:"id,omitempty"` + + // Kind: Identifies what kind of resource this is. Value: the fixed + // string "youtube#playlistImages". + Kind string `json:"kind,omitempty"` + + Snippet *PlaylistImageSnippet `json:"snippet,omitempty"` + + // ServerResponse contains the HTTP response code and headers from the + // server. + googleapi.ServerResponse `json:"-"` + + // ForceSendFields is a list of field names (e.g. "Id") to + // unconditionally include in API requests. By default, fields with + // empty or default values are omitted from API requests. However, any + // non-pointer, non-interface field appearing in ForceSendFields will be + // sent to the server regardless of whether the field is empty or not. + // This may be used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` + + // NullFields is a list of field names (e.g. "Id") to include in API + // requests with the JSON null value. By default, fields with empty + // values are omitted from API requests. However, any field with an + // empty value appearing in NullFields will be sent to the server as + // null. It is an error if a field in this list has a non-empty value. + // This may be used to include null fields in Patch requests. + NullFields []string `json:"-"` +} + +func (s *PlaylistImage) MarshalJSON() ([]byte, error) { + type NoMethod PlaylistImage + raw := NoMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) +} + +type PlaylistImageListResponse struct { + Items []*PlaylistImage `json:"items,omitempty"` + + // Kind: Identifies what kind of resource this is. Value: the fixed + // string "youtube#playlistImageListResponse". + Kind string `json:"kind,omitempty"` + + // NextPageToken: The token that can be used as the value of the + // pageToken parameter to retrieve the next page in the result set. + NextPageToken string `json:"nextPageToken,omitempty"` + + // PageInfo: General pagination information. + PageInfo *PageInfo `json:"pageInfo,omitempty"` + + // PrevPageToken: The token that can be used as the value of the + // pageToken parameter to retrieve the previous page in the result set. + PrevPageToken string `json:"prevPageToken,omitempty"` + + // ServerResponse contains the HTTP response code and headers from the + // server. + googleapi.ServerResponse `json:"-"` + + // ForceSendFields is a list of field names (e.g. "Items") to + // unconditionally include in API requests. By default, fields with + // empty or default values are omitted from API requests. However, any + // non-pointer, non-interface field appearing in ForceSendFields will be + // sent to the server regardless of whether the field is empty or not. + // This may be used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` + + // NullFields is a list of field names (e.g. "Items") to include in API + // requests with the JSON null value. By default, fields with empty + // values are omitted from API requests. However, any field with an + // empty value appearing in NullFields will be sent to the server as + // null. It is an error if a field in this list has a non-empty value. + // This may be used to include null fields in Patch requests. + NullFields []string `json:"-"` +} + +func (s *PlaylistImageListResponse) MarshalJSON() ([]byte, error) { + type NoMethod PlaylistImageListResponse + raw := NoMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) +} + +// PlaylistImageSnippet: A *playlistImage* resource identifies another +// resource, such as a image, that is associated with a playlist. In +// addition, the playlistImage resource contains details about the +// included resource that pertain specifically to how that resource is +// used in that playlist. YouTube uses playlists to identify special +// collections of videos for a channel, such as: - uploaded videos - +// favorite videos - positively rated (liked) videos - watch history To +// be more specific, these lists are associated with a channel, which is +// a collection of a person, group, or company's videos, playlists, and +// other YouTube information. You can retrieve the playlist IDs for each +// of these lists from the channel resource for a given channel. You can +// then use the playlistImages.list method to retrieve image data for +// any of those playlists. You can also add or remove images from those +// lists by calling the playlistImages.insert and playlistImages.delete +// methods. +type PlaylistImageSnippet struct { + // Height: The image height. + Height int64 `json:"height,omitempty"` + + // PlaylistId: The Playlist ID of the playlist this image is associated + // with. + PlaylistId string `json:"playlistId,omitempty"` + + // Type: The image type. + // + // Possible values: + // "hero" - The main image that will be used for this playlist. + Type string `json:"type,omitempty"` + + // Width: The image width. + Width int64 `json:"width,omitempty"` + + // ForceSendFields is a list of field names (e.g. "Height") to + // unconditionally include in API requests. By default, fields with + // empty or default values are omitted from API requests. However, any + // non-pointer, non-interface field appearing in ForceSendFields will be + // sent to the server regardless of whether the field is empty or not. + // This may be used to include empty fields in Patch requests. + ForceSendFields []string `json:"-"` + + // NullFields is a list of field names (e.g. "Height") to include in API + // requests with the JSON null value. By default, fields with empty + // values are omitted from API requests. However, any field with an + // empty value appearing in NullFields will be sent to the server as + // null. It is an error if a field in this list has a non-empty value. + // This may be used to include null fields in Patch requests. + NullFields []string `json:"-"` +} + +func (s *PlaylistImageSnippet) MarshalJSON() ([]byte, error) { + type NoMethod PlaylistImageSnippet + raw := NoMethod(*s) + return gensupport.MarshalJSON(raw, s.ForceSendFields, s.NullFields) +} + // PlaylistItem: A *playlistItem* resource identifies another resource, // such as a video, that is included in a playlist. In addition, the // playlistItem resource contains details about the included resource @@ -13007,13 +13156,6 @@ func (c *ChannelsListCall) CategoryId(categoryId string) *ChannelsListCall { return c } -// ForHandle sets the optional parameter "forHandle": Return the channel -// associated with a YouTube handle. UNIMPLEMENTED. -func (c *ChannelsListCall) ForHandle(forHandle string) *ChannelsListCall { - c.urlParams_.Set("forHandle", forHandle) - return c -} - // ForUsername sets the optional parameter "forUsername": Return the // channel associated with a YouTube username. func (c *ChannelsListCall) ForUsername(forUsername string) *ChannelsListCall { @@ -13203,11 +13345,6 @@ func (c *ChannelsListCall) Do(opts ...googleapi.CallOption) (*ChannelListRespons // "location": "query", // "type": "string" // }, - // "forHandle": { - // "description": "Return the channel associated with a YouTube handle. UNIMPLEMENTED.", - // "location": "query", - // "type": "string" - // }, // "forUsername": { // "description": "Return the channel associated with a YouTube username.", // "location": "query", @@ -19057,9 +19194,9 @@ func (c *MembershipsLevelsListCall) Do(opts ...googleapi.CallOption) (*Membershi } -// method id "youtube.playlistItems.delete": +// method id "youtube.playlistImages.delete": -type PlaylistItemsDeleteCall struct { +type PlaylistImagesDeleteCall struct { s *Service urlParams_ gensupport.URLParams ctx_ context.Context @@ -19067,10 +19204,14 @@ type PlaylistItemsDeleteCall struct { } // Delete: Deletes a resource. -// -// - id: . -func (r *PlaylistItemsService) Delete(id string) *PlaylistItemsDeleteCall { - c := &PlaylistItemsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} +func (r *PlaylistImagesService) Delete() *PlaylistImagesDeleteCall { + c := &PlaylistImagesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} + return c +} + +// Id sets the optional parameter "id": Id to identify this image. This +// is returned from by the List method. +func (c *PlaylistImagesDeleteCall) Id(id string) *PlaylistImagesDeleteCall { c.urlParams_.Set("id", id) return c } @@ -19087,7 +19228,7 @@ func (r *PlaylistItemsService) Delete(id string) *PlaylistItemsDeleteCall { // without having to provide authentication credentials for each // individual channel. The CMS account that the user authenticates with // must be linked to the specified YouTube content owner. -func (c *PlaylistItemsDeleteCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *PlaylistItemsDeleteCall { +func (c *PlaylistImagesDeleteCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *PlaylistImagesDeleteCall { c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner) return c } @@ -19095,7 +19236,7 @@ func (c *PlaylistItemsDeleteCall) OnBehalfOfContentOwner(onBehalfOfContentOwner // Fields allows partial responses to be retrieved. See // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse // for more information. -func (c *PlaylistItemsDeleteCall) Fields(s ...googleapi.Field) *PlaylistItemsDeleteCall { +func (c *PlaylistImagesDeleteCall) Fields(s ...googleapi.Field) *PlaylistImagesDeleteCall { c.urlParams_.Set("fields", googleapi.CombineFields(s)) return c } @@ -19103,21 +19244,21 @@ func (c *PlaylistItemsDeleteCall) Fields(s ...googleapi.Field) *PlaylistItemsDel // Context sets the context to be used in this call's Do method. Any // pending HTTP request will be aborted if the provided context is // canceled. -func (c *PlaylistItemsDeleteCall) Context(ctx context.Context) *PlaylistItemsDeleteCall { +func (c *PlaylistImagesDeleteCall) Context(ctx context.Context) *PlaylistImagesDeleteCall { c.ctx_ = ctx return c } // Header returns an http.Header that can be modified by the caller to // add HTTP headers to the request. -func (c *PlaylistItemsDeleteCall) Header() http.Header { +func (c *PlaylistImagesDeleteCall) Header() http.Header { if c.header_ == nil { c.header_ = make(http.Header) } return c.header_ } -func (c *PlaylistItemsDeleteCall) doRequest(alt string) (*http.Response, error) { +func (c *PlaylistImagesDeleteCall) doRequest(alt string) (*http.Response, error) { reqHeaders := make(http.Header) reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version) for k, v := range c.header_ { @@ -19127,7 +19268,7 @@ func (c *PlaylistItemsDeleteCall) doRequest(alt string) (*http.Response, error) var body io.Reader = nil c.urlParams_.Set("alt", alt) c.urlParams_.Set("prettyPrint", "false") - urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/playlistItems") + urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/playlistImages") urls += "?" + c.urlParams_.Encode() req, err := http.NewRequest("DELETE", urls, body) if err != nil { @@ -19137,8 +19278,8 @@ func (c *PlaylistItemsDeleteCall) doRequest(alt string) (*http.Response, error) return gensupport.SendRequest(c.ctx_, c.s.client, req) } -// Do executes the "youtube.playlistItems.delete" call. -func (c *PlaylistItemsDeleteCall) Do(opts ...googleapi.CallOption) error { +// Do executes the "youtube.playlistImages.delete" call. +func (c *PlaylistImagesDeleteCall) Do(opts ...googleapi.CallOption) error { gensupport.SetOptions(c.urlParams_, opts...) res, err := c.doRequest("json") if err != nil { @@ -19151,16 +19292,14 @@ func (c *PlaylistItemsDeleteCall) Do(opts ...googleapi.CallOption) error { return nil // { // "description": "Deletes a resource.", - // "flatPath": "youtube/v3/playlistItems", + // "flatPath": "youtube/v3/playlistImages", // "httpMethod": "DELETE", - // "id": "youtube.playlistItems.delete", - // "parameterOrder": [ - // "id" - // ], + // "id": "youtube.playlistImages.delete", + // "parameterOrder": [], // "parameters": { // "id": { + // "description": "Id to identify this image. This is returned from by the List method.", // "location": "query", - // "required": true, // "type": "string" // }, // "onBehalfOfContentOwner": { @@ -19169,7 +19308,7 @@ func (c *PlaylistItemsDeleteCall) Do(opts ...googleapi.CallOption) error { // "type": "string" // } // }, - // "path": "youtube/v3/playlistItems", + // "path": "youtube/v3/playlistImages", // "scopes": [ // "https://www.googleapis.com/auth/youtube", // "https://www.googleapis.com/auth/youtube.force-ssl", @@ -19179,25 +19318,20 @@ func (c *PlaylistItemsDeleteCall) Do(opts ...googleapi.CallOption) error { } -// method id "youtube.playlistItems.insert": +// method id "youtube.playlistImages.insert": -type PlaylistItemsInsertCall struct { - s *Service - playlistitem *PlaylistItem - urlParams_ gensupport.URLParams - ctx_ context.Context - header_ http.Header +type PlaylistImagesInsertCall struct { + s *Service + playlistimage *PlaylistImage + urlParams_ gensupport.URLParams + ctx_ context.Context + header_ http.Header } // Insert: Inserts a new resource into this collection. -// -// - part: The *part* parameter serves two purposes in this operation. -// It identifies the properties that the write operation will set as -// well as the properties that the API response will include. -func (r *PlaylistItemsService) Insert(part []string, playlistitem *PlaylistItem) *PlaylistItemsInsertCall { - c := &PlaylistItemsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)} - c.urlParams_.SetMulti("part", append([]string{}, part...)) - c.playlistitem = playlistitem +func (r *PlaylistImagesService) Insert(playlistimage *PlaylistImage) *PlaylistImagesInsertCall { + c := &PlaylistImagesInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.playlistimage = playlistimage return c } @@ -19213,15 +19347,46 @@ func (r *PlaylistItemsService) Insert(part []string, playlistitem *PlaylistItem) // without having to provide authentication credentials for each // individual channel. The CMS account that the user authenticates with // must be linked to the specified YouTube content owner. -func (c *PlaylistItemsInsertCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *PlaylistItemsInsertCall { +func (c *PlaylistImagesInsertCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *PlaylistImagesInsertCall { c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner) return c } +// OnBehalfOfContentOwnerChannel sets the optional parameter +// "onBehalfOfContentOwnerChannel": This parameter can only be used in a +// properly authorized request. *Note:* This parameter is intended +// exclusively for YouTube content partners. The +// *onBehalfOfContentOwnerChannel* parameter specifies the YouTube +// channel ID of the channel to which a video is being added. This +// parameter is required when a request specifies a value for the +// onBehalfOfContentOwner parameter, and it can only be used in +// conjunction with that parameter. In addition, the request must be +// authorized using a CMS account that is linked to the content owner +// that the onBehalfOfContentOwner parameter specifies. Finally, the +// channel that the onBehalfOfContentOwnerChannel parameter value +// specifies must be linked to the content owner that the +// onBehalfOfContentOwner parameter specifies. This parameter is +// intended for YouTube content partners that own and manage many +// different YouTube channels. It allows content owners to authenticate +// once and perform actions on behalf of the channel specified in the +// parameter value, without having to provide authentication credentials +// for each separate channel. +func (c *PlaylistImagesInsertCall) OnBehalfOfContentOwnerChannel(onBehalfOfContentOwnerChannel string) *PlaylistImagesInsertCall { + c.urlParams_.Set("onBehalfOfContentOwnerChannel", onBehalfOfContentOwnerChannel) + return c +} + +// Part sets the optional parameter "part": The *part* parameter +// specifies the properties that the API response will include. +func (c *PlaylistImagesInsertCall) Part(part ...string) *PlaylistImagesInsertCall { + c.urlParams_.SetMulti("part", append([]string{}, part...)) + return c +} + // Fields allows partial responses to be retrieved. See // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse // for more information. -func (c *PlaylistItemsInsertCall) Fields(s ...googleapi.Field) *PlaylistItemsInsertCall { +func (c *PlaylistImagesInsertCall) Fields(s ...googleapi.Field) *PlaylistImagesInsertCall { c.urlParams_.Set("fields", googleapi.CombineFields(s)) return c } @@ -19229,21 +19394,21 @@ func (c *PlaylistItemsInsertCall) Fields(s ...googleapi.Field) *PlaylistItemsIns // Context sets the context to be used in this call's Do method. Any // pending HTTP request will be aborted if the provided context is // canceled. -func (c *PlaylistItemsInsertCall) Context(ctx context.Context) *PlaylistItemsInsertCall { +func (c *PlaylistImagesInsertCall) Context(ctx context.Context) *PlaylistImagesInsertCall { c.ctx_ = ctx return c } // Header returns an http.Header that can be modified by the caller to // add HTTP headers to the request. -func (c *PlaylistItemsInsertCall) Header() http.Header { +func (c *PlaylistImagesInsertCall) Header() http.Header { if c.header_ == nil { c.header_ = make(http.Header) } return c.header_ } -func (c *PlaylistItemsInsertCall) doRequest(alt string) (*http.Response, error) { +func (c *PlaylistImagesInsertCall) doRequest(alt string) (*http.Response, error) { reqHeaders := make(http.Header) reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version) for k, v := range c.header_ { @@ -19251,14 +19416,14 @@ func (c *PlaylistItemsInsertCall) doRequest(alt string) (*http.Response, error) } reqHeaders.Set("User-Agent", c.s.userAgent()) var body io.Reader = nil - body, err := googleapi.WithoutDataWrapper.JSONReader(c.playlistitem) + body, err := googleapi.WithoutDataWrapper.JSONReader(c.playlistimage) if err != nil { return nil, err } reqHeaders.Set("Content-Type", "application/json") c.urlParams_.Set("alt", alt) c.urlParams_.Set("prettyPrint", "false") - urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/playlistItems") + urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/playlistImages") urls += "?" + c.urlParams_.Encode() req, err := http.NewRequest("POST", urls, body) if err != nil { @@ -19268,14 +19433,14 @@ func (c *PlaylistItemsInsertCall) doRequest(alt string) (*http.Response, error) return gensupport.SendRequest(c.ctx_, c.s.client, req) } -// Do executes the "youtube.playlistItems.insert" call. -// Exactly one of *PlaylistItem or error will be non-nil. Any non-2xx +// Do executes the "youtube.playlistImages.insert" call. +// Exactly one of *PlaylistImage or error will be non-nil. Any non-2xx // status code is an error. Response headers are in either -// *PlaylistItem.ServerResponse.Header or (if a response was returned at -// all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified -// to check whether the returned error was because -// http.StatusNotModified was returned. -func (c *PlaylistItemsInsertCall) Do(opts ...googleapi.CallOption) (*PlaylistItem, error) { +// *PlaylistImage.ServerResponse.Header or (if a response was returned +// at all) in error.(*googleapi.Error).Header. Use +// googleapi.IsNotModified to check whether the returned error was +// because http.StatusNotModified was returned. +func (c *PlaylistImagesInsertCall) Do(opts ...googleapi.CallOption) (*PlaylistImage, error) { gensupport.SetOptions(c.urlParams_, opts...) res, err := c.doRequest("json") if res != nil && res.StatusCode == http.StatusNotModified { @@ -19294,7 +19459,7 @@ func (c *PlaylistItemsInsertCall) Do(opts ...googleapi.CallOption) (*PlaylistIte if err := googleapi.CheckResponse(res); err != nil { return nil, gensupport.WrapError(err) } - ret := &PlaylistItem{ + ret := &PlaylistImage{ ServerResponse: googleapi.ServerResponse{ Header: res.Header, HTTPStatusCode: res.StatusCode, @@ -19307,32 +19472,34 @@ func (c *PlaylistItemsInsertCall) Do(opts ...googleapi.CallOption) (*PlaylistIte return ret, nil // { // "description": "Inserts a new resource into this collection.", - // "flatPath": "youtube/v3/playlistItems", + // "flatPath": "youtube/v3/playlistImages", // "httpMethod": "POST", - // "id": "youtube.playlistItems.insert", - // "parameterOrder": [ - // "part" - // ], + // "id": "youtube.playlistImages.insert", + // "parameterOrder": [], // "parameters": { // "onBehalfOfContentOwner": { // "description": "*Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwner* parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner.", // "location": "query", // "type": "string" // }, + // "onBehalfOfContentOwnerChannel": { + // "description": "This parameter can only be used in a properly authorized request. *Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwnerChannel* parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel.", + // "location": "query", + // "type": "string" + // }, // "part": { - // "description": "The *part* parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response will include.", + // "description": "The *part* parameter specifies the properties that the API response will include.", // "location": "query", // "repeated": true, - // "required": true, // "type": "string" // } // }, - // "path": "youtube/v3/playlistItems", + // "path": "youtube/v3/playlistImages", // "request": { - // "$ref": "PlaylistItem" + // "$ref": "PlaylistImage" // }, // "response": { - // "$ref": "PlaylistItem" + // "$ref": "PlaylistImage" // }, // "scopes": [ // "https://www.googleapis.com/auth/youtube", @@ -19343,9 +19510,9 @@ func (c *PlaylistItemsInsertCall) Do(opts ...googleapi.CallOption) (*PlaylistIte } -// method id "youtube.playlistItems.list": +// method id "youtube.playlistImages.list": -type PlaylistItemsListCall struct { +type PlaylistImagesListCall struct { s *Service urlParams_ gensupport.URLParams ifNoneMatch_ string @@ -19354,32 +19521,15 @@ type PlaylistItemsListCall struct { } // List: Retrieves a list of resources, possibly filtered. -// -// - part: The *part* parameter specifies a comma-separated list of one -// or more playlistItem resource properties that the API response will -// include. If the parameter identifies a property that contains child -// properties, the child properties will be included in the response. -// For example, in a playlistItem resource, the snippet property -// contains numerous fields, including the title, description, -// position, and resourceId properties. As such, if you set -// *part=snippet*, the API response will contain all of those -// properties. -func (r *PlaylistItemsService) List(part []string) *PlaylistItemsListCall { - c := &PlaylistItemsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} - c.urlParams_.SetMulti("part", append([]string{}, part...)) - return c -} - -// Id sets the optional parameter "id": -func (c *PlaylistItemsListCall) Id(id ...string) *PlaylistItemsListCall { - c.urlParams_.SetMulti("id", append([]string{}, id...)) +func (r *PlaylistImagesService) List() *PlaylistImagesListCall { + c := &PlaylistImagesListCall{s: r.s, urlParams_: make(gensupport.URLParams)} return c } // MaxResults sets the optional parameter "maxResults": The *maxResults* // parameter specifies the maximum number of items that should be // returned in the result set. -func (c *PlaylistItemsListCall) MaxResults(maxResults int64) *PlaylistItemsListCall { +func (c *PlaylistImagesListCall) MaxResults(maxResults int64) *PlaylistImagesListCall { c.urlParams_.Set("maxResults", fmt.Sprint(maxResults)) return c } @@ -19396,23 +19546,753 @@ func (c *PlaylistItemsListCall) MaxResults(maxResults int64) *PlaylistItemsListC // without having to provide authentication credentials for each // individual channel. The CMS account that the user authenticates with // must be linked to the specified YouTube content owner. -func (c *PlaylistItemsListCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *PlaylistItemsListCall { +func (c *PlaylistImagesListCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *PlaylistImagesListCall { c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner) return c } -// PageToken sets the optional parameter "pageToken": The *pageToken* -// parameter identifies a specific page in the result set that should be -// returned. In an API response, the nextPageToken and prevPageToken -// properties identify other pages that could be retrieved. -func (c *PlaylistItemsListCall) PageToken(pageToken string) *PlaylistItemsListCall { - c.urlParams_.Set("pageToken", pageToken) - return c -} - -// PlaylistId sets the optional parameter "playlistId": Return the -// playlist items within the given playlist. -func (c *PlaylistItemsListCall) PlaylistId(playlistId string) *PlaylistItemsListCall { +// OnBehalfOfContentOwnerChannel sets the optional parameter +// "onBehalfOfContentOwnerChannel": This parameter can only be used in a +// properly authorized request. *Note:* This parameter is intended +// exclusively for YouTube content partners. The +// *onBehalfOfContentOwnerChannel* parameter specifies the YouTube +// channel ID of the channel to which a video is being added. This +// parameter is required when a request specifies a value for the +// onBehalfOfContentOwner parameter, and it can only be used in +// conjunction with that parameter. In addition, the request must be +// authorized using a CMS account that is linked to the content owner +// that the onBehalfOfContentOwner parameter specifies. Finally, the +// channel that the onBehalfOfContentOwnerChannel parameter value +// specifies must be linked to the content owner that the +// onBehalfOfContentOwner parameter specifies. This parameter is +// intended for YouTube content partners that own and manage many +// different YouTube channels. It allows content owners to authenticate +// once and perform actions on behalf of the channel specified in the +// parameter value, without having to provide authentication credentials +// for each separate channel. +func (c *PlaylistImagesListCall) OnBehalfOfContentOwnerChannel(onBehalfOfContentOwnerChannel string) *PlaylistImagesListCall { + c.urlParams_.Set("onBehalfOfContentOwnerChannel", onBehalfOfContentOwnerChannel) + return c +} + +// PageToken sets the optional parameter "pageToken": The *pageToken* +// parameter identifies a specific page in the result set that should be +// returned. In an API response, the nextPageToken and prevPageToken +// properties identify other pages that could be retrieved. +func (c *PlaylistImagesListCall) PageToken(pageToken string) *PlaylistImagesListCall { + c.urlParams_.Set("pageToken", pageToken) + return c +} + +// Parent sets the optional parameter "parent": Return PlaylistImages +// for this playlist id. +func (c *PlaylistImagesListCall) Parent(parent string) *PlaylistImagesListCall { + c.urlParams_.Set("parent", parent) + return c +} + +// Part sets the optional parameter "part": The *part* parameter +// specifies a comma-separated list of one or more playlistImage +// resource properties that the API response will include. If the +// parameter identifies a property that contains child properties, the +// child properties will be included in the response. +func (c *PlaylistImagesListCall) Part(part ...string) *PlaylistImagesListCall { + c.urlParams_.SetMulti("part", append([]string{}, part...)) + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *PlaylistImagesListCall) Fields(s ...googleapi.Field) *PlaylistImagesListCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// IfNoneMatch sets the optional parameter which makes the operation +// fail if the object's ETag matches the given value. This is useful for +// getting updates only after the object has changed since the last +// request. Use googleapi.IsNotModified to check whether the response +// error from Do is the result of In-None-Match. +func (c *PlaylistImagesListCall) IfNoneMatch(entityTag string) *PlaylistImagesListCall { + c.ifNoneMatch_ = entityTag + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *PlaylistImagesListCall) Context(ctx context.Context) *PlaylistImagesListCall { + c.ctx_ = ctx + return c +} + +// Header returns an http.Header that can be modified by the caller to +// add HTTP headers to the request. +func (c *PlaylistImagesListCall) Header() http.Header { + if c.header_ == nil { + c.header_ = make(http.Header) + } + return c.header_ +} + +func (c *PlaylistImagesListCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version) + for k, v := range c.header_ { + reqHeaders[k] = v + } + reqHeaders.Set("User-Agent", c.s.userAgent()) + if c.ifNoneMatch_ != "" { + reqHeaders.Set("If-None-Match", c.ifNoneMatch_) + } + var body io.Reader = nil + c.urlParams_.Set("alt", alt) + c.urlParams_.Set("prettyPrint", "false") + urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/playlistImages") + urls += "?" + c.urlParams_.Encode() + req, err := http.NewRequest("GET", urls, body) + if err != nil { + return nil, err + } + req.Header = reqHeaders + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "youtube.playlistImages.list" call. +// Exactly one of *PlaylistImageListResponse or error will be non-nil. +// Any non-2xx status code is an error. Response headers are in either +// *PlaylistImageListResponse.ServerResponse.Header or (if a response +// was returned at all) in error.(*googleapi.Error).Header. Use +// googleapi.IsNotModified to check whether the returned error was +// because http.StatusNotModified was returned. +func (c *PlaylistImagesListCall) Do(opts ...googleapi.CallOption) (*PlaylistImageListResponse, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, gensupport.WrapError(&googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + }) + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, gensupport.WrapError(err) + } + ret := &PlaylistImageListResponse{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := gensupport.DecodeResponse(target, res); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Retrieves a list of resources, possibly filtered.", + // "flatPath": "youtube/v3/playlistImages", + // "httpMethod": "GET", + // "id": "youtube.playlistImages.list", + // "parameterOrder": [], + // "parameters": { + // "maxResults": { + // "default": "5", + // "description": "The *maxResults* parameter specifies the maximum number of items that should be returned in the result set.", + // "format": "uint32", + // "location": "query", + // "maximum": "50", + // "minimum": "0", + // "type": "integer" + // }, + // "onBehalfOfContentOwner": { + // "description": "*Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwner* parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner.", + // "location": "query", + // "type": "string" + // }, + // "onBehalfOfContentOwnerChannel": { + // "description": "This parameter can only be used in a properly authorized request. *Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwnerChannel* parameter specifies the YouTube channel ID of the channel to which a video is being added. This parameter is required when a request specifies a value for the onBehalfOfContentOwner parameter, and it can only be used in conjunction with that parameter. In addition, the request must be authorized using a CMS account that is linked to the content owner that the onBehalfOfContentOwner parameter specifies. Finally, the channel that the onBehalfOfContentOwnerChannel parameter value specifies must be linked to the content owner that the onBehalfOfContentOwner parameter specifies. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and perform actions on behalf of the channel specified in the parameter value, without having to provide authentication credentials for each separate channel.", + // "location": "query", + // "type": "string" + // }, + // "pageToken": { + // "description": "The *pageToken* parameter identifies a specific page in the result set that should be returned. In an API response, the nextPageToken and prevPageToken properties identify other pages that could be retrieved.", + // "location": "query", + // "type": "string" + // }, + // "parent": { + // "description": "Return PlaylistImages for this playlist id.", + // "location": "query", + // "type": "string" + // }, + // "part": { + // "description": "The *part* parameter specifies a comma-separated list of one or more playlistImage resource properties that the API response will include. If the parameter identifies a property that contains child properties, the child properties will be included in the response.", + // "location": "query", + // "repeated": true, + // "type": "string" + // } + // }, + // "path": "youtube/v3/playlistImages", + // "response": { + // "$ref": "PlaylistImageListResponse" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/youtube", + // "https://www.googleapis.com/auth/youtube.force-ssl", + // "https://www.googleapis.com/auth/youtube.readonly", + // "https://www.googleapis.com/auth/youtubepartner" + // ] + // } + +} + +// Pages invokes f for each page of results. +// A non-nil error returned from f will halt the iteration. +// The provided context supersedes any context provided to the Context method. +func (c *PlaylistImagesListCall) Pages(ctx context.Context, f func(*PlaylistImageListResponse) error) error { + c.ctx_ = ctx + defer c.PageToken(c.urlParams_.Get("pageToken")) // reset paging to original point + for { + x, err := c.Do() + if err != nil { + return err + } + if err := f(x); err != nil { + return err + } + if x.NextPageToken == "" { + return nil + } + c.PageToken(x.NextPageToken) + } +} + +// method id "youtube.playlistImages.update": + +type PlaylistImagesUpdateCall struct { + s *Service + playlistimage *PlaylistImage + urlParams_ gensupport.URLParams + ctx_ context.Context + header_ http.Header +} + +// Update: Updates an existing resource. +func (r *PlaylistImagesService) Update(playlistimage *PlaylistImage) *PlaylistImagesUpdateCall { + c := &PlaylistImagesUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.playlistimage = playlistimage + return c +} + +// OnBehalfOfContentOwner sets the optional parameter +// "onBehalfOfContentOwner": *Note:* This parameter is intended +// exclusively for YouTube content partners. The +// *onBehalfOfContentOwner* parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting +// on behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and +// manage many different YouTube channels. It allows content owners to +// authenticate once and get access to all their video and channel data, +// without having to provide authentication credentials for each +// individual channel. The CMS account that the user authenticates with +// must be linked to the specified YouTube content owner. +func (c *PlaylistImagesUpdateCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *PlaylistImagesUpdateCall { + c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner) + return c +} + +// Part sets the optional parameter "part": The *part* parameter +// specifies the properties that the API response will include. +func (c *PlaylistImagesUpdateCall) Part(part ...string) *PlaylistImagesUpdateCall { + c.urlParams_.SetMulti("part", append([]string{}, part...)) + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *PlaylistImagesUpdateCall) Fields(s ...googleapi.Field) *PlaylistImagesUpdateCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *PlaylistImagesUpdateCall) Context(ctx context.Context) *PlaylistImagesUpdateCall { + c.ctx_ = ctx + return c +} + +// Header returns an http.Header that can be modified by the caller to +// add HTTP headers to the request. +func (c *PlaylistImagesUpdateCall) Header() http.Header { + if c.header_ == nil { + c.header_ = make(http.Header) + } + return c.header_ +} + +func (c *PlaylistImagesUpdateCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version) + for k, v := range c.header_ { + reqHeaders[k] = v + } + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + body, err := googleapi.WithoutDataWrapper.JSONReader(c.playlistimage) + if err != nil { + return nil, err + } + reqHeaders.Set("Content-Type", "application/json") + c.urlParams_.Set("alt", alt) + c.urlParams_.Set("prettyPrint", "false") + urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/playlistImages") + urls += "?" + c.urlParams_.Encode() + req, err := http.NewRequest("PUT", urls, body) + if err != nil { + return nil, err + } + req.Header = reqHeaders + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "youtube.playlistImages.update" call. +// Exactly one of *PlaylistImage or error will be non-nil. Any non-2xx +// status code is an error. Response headers are in either +// *PlaylistImage.ServerResponse.Header or (if a response was returned +// at all) in error.(*googleapi.Error).Header. Use +// googleapi.IsNotModified to check whether the returned error was +// because http.StatusNotModified was returned. +func (c *PlaylistImagesUpdateCall) Do(opts ...googleapi.CallOption) (*PlaylistImage, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, gensupport.WrapError(&googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + }) + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, gensupport.WrapError(err) + } + ret := &PlaylistImage{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := gensupport.DecodeResponse(target, res); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Updates an existing resource.", + // "flatPath": "youtube/v3/playlistImages", + // "httpMethod": "PUT", + // "id": "youtube.playlistImages.update", + // "parameterOrder": [], + // "parameters": { + // "onBehalfOfContentOwner": { + // "description": "*Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwner* parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner.", + // "location": "query", + // "type": "string" + // }, + // "part": { + // "description": "The *part* parameter specifies the properties that the API response will include.", + // "location": "query", + // "repeated": true, + // "type": "string" + // } + // }, + // "path": "youtube/v3/playlistImages", + // "request": { + // "$ref": "PlaylistImage" + // }, + // "response": { + // "$ref": "PlaylistImage" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/youtube", + // "https://www.googleapis.com/auth/youtube.force-ssl", + // "https://www.googleapis.com/auth/youtubepartner" + // ] + // } + +} + +// method id "youtube.playlistItems.delete": + +type PlaylistItemsDeleteCall struct { + s *Service + urlParams_ gensupport.URLParams + ctx_ context.Context + header_ http.Header +} + +// Delete: Deletes a resource. +// +// - id: . +func (r *PlaylistItemsService) Delete(id string) *PlaylistItemsDeleteCall { + c := &PlaylistItemsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.urlParams_.Set("id", id) + return c +} + +// OnBehalfOfContentOwner sets the optional parameter +// "onBehalfOfContentOwner": *Note:* This parameter is intended +// exclusively for YouTube content partners. The +// *onBehalfOfContentOwner* parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting +// on behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and +// manage many different YouTube channels. It allows content owners to +// authenticate once and get access to all their video and channel data, +// without having to provide authentication credentials for each +// individual channel. The CMS account that the user authenticates with +// must be linked to the specified YouTube content owner. +func (c *PlaylistItemsDeleteCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *PlaylistItemsDeleteCall { + c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner) + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *PlaylistItemsDeleteCall) Fields(s ...googleapi.Field) *PlaylistItemsDeleteCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *PlaylistItemsDeleteCall) Context(ctx context.Context) *PlaylistItemsDeleteCall { + c.ctx_ = ctx + return c +} + +// Header returns an http.Header that can be modified by the caller to +// add HTTP headers to the request. +func (c *PlaylistItemsDeleteCall) Header() http.Header { + if c.header_ == nil { + c.header_ = make(http.Header) + } + return c.header_ +} + +func (c *PlaylistItemsDeleteCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version) + for k, v := range c.header_ { + reqHeaders[k] = v + } + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + c.urlParams_.Set("alt", alt) + c.urlParams_.Set("prettyPrint", "false") + urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/playlistItems") + urls += "?" + c.urlParams_.Encode() + req, err := http.NewRequest("DELETE", urls, body) + if err != nil { + return nil, err + } + req.Header = reqHeaders + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "youtube.playlistItems.delete" call. +func (c *PlaylistItemsDeleteCall) Do(opts ...googleapi.CallOption) error { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if err != nil { + return err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return gensupport.WrapError(err) + } + return nil + // { + // "description": "Deletes a resource.", + // "flatPath": "youtube/v3/playlistItems", + // "httpMethod": "DELETE", + // "id": "youtube.playlistItems.delete", + // "parameterOrder": [ + // "id" + // ], + // "parameters": { + // "id": { + // "location": "query", + // "required": true, + // "type": "string" + // }, + // "onBehalfOfContentOwner": { + // "description": "*Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwner* parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner.", + // "location": "query", + // "type": "string" + // } + // }, + // "path": "youtube/v3/playlistItems", + // "scopes": [ + // "https://www.googleapis.com/auth/youtube", + // "https://www.googleapis.com/auth/youtube.force-ssl", + // "https://www.googleapis.com/auth/youtubepartner" + // ] + // } + +} + +// method id "youtube.playlistItems.insert": + +type PlaylistItemsInsertCall struct { + s *Service + playlistitem *PlaylistItem + urlParams_ gensupport.URLParams + ctx_ context.Context + header_ http.Header +} + +// Insert: Inserts a new resource into this collection. +// +// - part: The *part* parameter serves two purposes in this operation. +// It identifies the properties that the write operation will set as +// well as the properties that the API response will include. +func (r *PlaylistItemsService) Insert(part []string, playlistitem *PlaylistItem) *PlaylistItemsInsertCall { + c := &PlaylistItemsInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.urlParams_.SetMulti("part", append([]string{}, part...)) + c.playlistitem = playlistitem + return c +} + +// OnBehalfOfContentOwner sets the optional parameter +// "onBehalfOfContentOwner": *Note:* This parameter is intended +// exclusively for YouTube content partners. The +// *onBehalfOfContentOwner* parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting +// on behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and +// manage many different YouTube channels. It allows content owners to +// authenticate once and get access to all their video and channel data, +// without having to provide authentication credentials for each +// individual channel. The CMS account that the user authenticates with +// must be linked to the specified YouTube content owner. +func (c *PlaylistItemsInsertCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *PlaylistItemsInsertCall { + c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner) + return c +} + +// Fields allows partial responses to be retrieved. See +// https://developers.google.com/gdata/docs/2.0/basics#PartialResponse +// for more information. +func (c *PlaylistItemsInsertCall) Fields(s ...googleapi.Field) *PlaylistItemsInsertCall { + c.urlParams_.Set("fields", googleapi.CombineFields(s)) + return c +} + +// Context sets the context to be used in this call's Do method. Any +// pending HTTP request will be aborted if the provided context is +// canceled. +func (c *PlaylistItemsInsertCall) Context(ctx context.Context) *PlaylistItemsInsertCall { + c.ctx_ = ctx + return c +} + +// Header returns an http.Header that can be modified by the caller to +// add HTTP headers to the request. +func (c *PlaylistItemsInsertCall) Header() http.Header { + if c.header_ == nil { + c.header_ = make(http.Header) + } + return c.header_ +} + +func (c *PlaylistItemsInsertCall) doRequest(alt string) (*http.Response, error) { + reqHeaders := make(http.Header) + reqHeaders.Set("x-goog-api-client", "gl-go/"+gensupport.GoVersion()+" gdcl/"+internal.Version) + for k, v := range c.header_ { + reqHeaders[k] = v + } + reqHeaders.Set("User-Agent", c.s.userAgent()) + var body io.Reader = nil + body, err := googleapi.WithoutDataWrapper.JSONReader(c.playlistitem) + if err != nil { + return nil, err + } + reqHeaders.Set("Content-Type", "application/json") + c.urlParams_.Set("alt", alt) + c.urlParams_.Set("prettyPrint", "false") + urls := googleapi.ResolveRelative(c.s.BasePath, "youtube/v3/playlistItems") + urls += "?" + c.urlParams_.Encode() + req, err := http.NewRequest("POST", urls, body) + if err != nil { + return nil, err + } + req.Header = reqHeaders + return gensupport.SendRequest(c.ctx_, c.s.client, req) +} + +// Do executes the "youtube.playlistItems.insert" call. +// Exactly one of *PlaylistItem or error will be non-nil. Any non-2xx +// status code is an error. Response headers are in either +// *PlaylistItem.ServerResponse.Header or (if a response was returned at +// all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified +// to check whether the returned error was because +// http.StatusNotModified was returned. +func (c *PlaylistItemsInsertCall) Do(opts ...googleapi.CallOption) (*PlaylistItem, error) { + gensupport.SetOptions(c.urlParams_, opts...) + res, err := c.doRequest("json") + if res != nil && res.StatusCode == http.StatusNotModified { + if res.Body != nil { + res.Body.Close() + } + return nil, gensupport.WrapError(&googleapi.Error{ + Code: res.StatusCode, + Header: res.Header, + }) + } + if err != nil { + return nil, err + } + defer googleapi.CloseBody(res) + if err := googleapi.CheckResponse(res); err != nil { + return nil, gensupport.WrapError(err) + } + ret := &PlaylistItem{ + ServerResponse: googleapi.ServerResponse{ + Header: res.Header, + HTTPStatusCode: res.StatusCode, + }, + } + target := &ret + if err := gensupport.DecodeResponse(target, res); err != nil { + return nil, err + } + return ret, nil + // { + // "description": "Inserts a new resource into this collection.", + // "flatPath": "youtube/v3/playlistItems", + // "httpMethod": "POST", + // "id": "youtube.playlistItems.insert", + // "parameterOrder": [ + // "part" + // ], + // "parameters": { + // "onBehalfOfContentOwner": { + // "description": "*Note:* This parameter is intended exclusively for YouTube content partners. The *onBehalfOfContentOwner* parameter indicates that the request's authorization credentials identify a YouTube CMS user who is acting on behalf of the content owner specified in the parameter value. This parameter is intended for YouTube content partners that own and manage many different YouTube channels. It allows content owners to authenticate once and get access to all their video and channel data, without having to provide authentication credentials for each individual channel. The CMS account that the user authenticates with must be linked to the specified YouTube content owner.", + // "location": "query", + // "type": "string" + // }, + // "part": { + // "description": "The *part* parameter serves two purposes in this operation. It identifies the properties that the write operation will set as well as the properties that the API response will include.", + // "location": "query", + // "repeated": true, + // "required": true, + // "type": "string" + // } + // }, + // "path": "youtube/v3/playlistItems", + // "request": { + // "$ref": "PlaylistItem" + // }, + // "response": { + // "$ref": "PlaylistItem" + // }, + // "scopes": [ + // "https://www.googleapis.com/auth/youtube", + // "https://www.googleapis.com/auth/youtube.force-ssl", + // "https://www.googleapis.com/auth/youtubepartner" + // ] + // } + +} + +// method id "youtube.playlistItems.list": + +type PlaylistItemsListCall struct { + s *Service + urlParams_ gensupport.URLParams + ifNoneMatch_ string + ctx_ context.Context + header_ http.Header +} + +// List: Retrieves a list of resources, possibly filtered. +// +// - part: The *part* parameter specifies a comma-separated list of one +// or more playlistItem resource properties that the API response will +// include. If the parameter identifies a property that contains child +// properties, the child properties will be included in the response. +// For example, in a playlistItem resource, the snippet property +// contains numerous fields, including the title, description, +// position, and resourceId properties. As such, if you set +// *part=snippet*, the API response will contain all of those +// properties. +func (r *PlaylistItemsService) List(part []string) *PlaylistItemsListCall { + c := &PlaylistItemsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} + c.urlParams_.SetMulti("part", append([]string{}, part...)) + return c +} + +// Id sets the optional parameter "id": +func (c *PlaylistItemsListCall) Id(id ...string) *PlaylistItemsListCall { + c.urlParams_.SetMulti("id", append([]string{}, id...)) + return c +} + +// MaxResults sets the optional parameter "maxResults": The *maxResults* +// parameter specifies the maximum number of items that should be +// returned in the result set. +func (c *PlaylistItemsListCall) MaxResults(maxResults int64) *PlaylistItemsListCall { + c.urlParams_.Set("maxResults", fmt.Sprint(maxResults)) + return c +} + +// OnBehalfOfContentOwner sets the optional parameter +// "onBehalfOfContentOwner": *Note:* This parameter is intended +// exclusively for YouTube content partners. The +// *onBehalfOfContentOwner* parameter indicates that the request's +// authorization credentials identify a YouTube CMS user who is acting +// on behalf of the content owner specified in the parameter value. This +// parameter is intended for YouTube content partners that own and +// manage many different YouTube channels. It allows content owners to +// authenticate once and get access to all their video and channel data, +// without having to provide authentication credentials for each +// individual channel. The CMS account that the user authenticates with +// must be linked to the specified YouTube content owner. +func (c *PlaylistItemsListCall) OnBehalfOfContentOwner(onBehalfOfContentOwner string) *PlaylistItemsListCall { + c.urlParams_.Set("onBehalfOfContentOwner", onBehalfOfContentOwner) + return c +} + +// PageToken sets the optional parameter "pageToken": The *pageToken* +// parameter identifies a specific page in the result set that should be +// returned. In an API response, the nextPageToken and prevPageToken +// properties identify other pages that could be retrieved. +func (c *PlaylistItemsListCall) PageToken(pageToken string) *PlaylistItemsListCall { + c.urlParams_.Set("pageToken", pageToken) + return c +} + +// PlaylistId sets the optional parameter "playlistId": Return the +// playlist items within the given playlist. +func (c *PlaylistItemsListCall) PlaylistId(playlistId string) *PlaylistItemsListCall { c.urlParams_.Set("playlistId", playlistId) return c } @@ -20749,13 +21629,6 @@ func (c *SearchListCall) RegionCode(regionCode string) *SearchListCall { return c } -// RelatedToVideoId sets the optional parameter "relatedToVideoId": -// Search related to a resource. -func (c *SearchListCall) RelatedToVideoId(relatedToVideoId string) *SearchListCall { - c.urlParams_.Set("relatedToVideoId", relatedToVideoId) - return c -} - // RelevanceLanguage sets the optional parameter "relevanceLanguage": // Return results relevant to this language. func (c *SearchListCall) RelevanceLanguage(relevanceLanguage string) *SearchListCall { @@ -21187,11 +22060,6 @@ func (c *SearchListCall) Do(opts ...googleapi.CallOption) (*SearchListResponse, // "location": "query", // "type": "string" // }, - // "relatedToVideoId": { - // "description": "Search related to a resource.", - // "location": "query", - // "type": "string" - // }, // "relevanceLanguage": { // "description": "Return results relevant to this language.", // "location": "query",