Documentation

Overview

Package script provides access to the Apps Script API.

For product documentation, see: https://developers.google.com/apps-script/api/

Creating a client

Usage example:

import "google.golang.org/api/script/v1"
...
ctx := context.Background()
scriptService, err := script.NewService(ctx)

In this example, Google Application Default Credentials are used for authentication.

For information on how to create and obtain Application Default Credentials, see https://developers.google.com/identity/protocols/application-default-credentials.

Other authentication options

By default, all available scopes (see "Constants") are used to authenticate. To restrict scopes, use option.WithScopes:

scriptService, err := script.NewService(ctx, option.WithScopes(script.UserinfoEmailScope))

To use an API key for authentication (note: some APIs do not support API keys), use option.WithAPIKey:

scriptService, err := script.NewService(ctx, option.WithAPIKey("AIza..."))

To use an OAuth token (e.g., a user token obtained via a three-legged OAuth flow), use option.WithTokenSource:

config := &oauth2.Config{...}
// ...
token, err := config.Exchange(ctx, ...)
scriptService, err := script.NewService(ctx, option.WithTokenSource(config.TokenSource(ctx, token)))

See https://godoc.org/google.golang.org/api/option/ for details on options.

Index

Constants

View Source
const (
	// Read, compose, send, and permanently delete all your email from Gmail
	MailGoogleComScope = "https://mail.google.com/"

	// See, edit, share, and permanently delete all the calendars you can
	// access using Google Calendar
	WwwGoogleComCalendarFeedsScope = "https://www.google.com/calendar/feeds"

	// See, edit, download, and permanently delete your contacts
	WwwGoogleComM8FeedsScope = "https://www.google.com/m8/feeds"

	// View and manage the provisioning of groups on your domain
	AdminDirectoryGroupScope = "https://www.googleapis.com/auth/admin.directory.group"

	// View and manage the provisioning of users on your domain
	AdminDirectoryUserScope = "https://www.googleapis.com/auth/admin.directory.user"

	// View and manage your Google Docs documents
	DocumentsScope = "https://www.googleapis.com/auth/documents"

	// See, edit, create, and delete all of your Google Drive files
	DriveScope = "https://www.googleapis.com/auth/drive"

	// View and manage your forms in Google Drive
	FormsScope = "https://www.googleapis.com/auth/forms"

	// View and manage forms that this application has been installed in
	FormsCurrentonlyScope = "https://www.googleapis.com/auth/forms.currentonly"

	// View and manage your Google Groups
	GroupsScope = "https://www.googleapis.com/auth/groups"

	// Create and update Google Apps Script deployments
	ScriptDeploymentsScope = "https://www.googleapis.com/auth/script.deployments"

	// View Google Apps Script deployments
	ScriptDeploymentsReadonlyScope = "https://www.googleapis.com/auth/script.deployments.readonly"

	// View Google Apps Script project's metrics
	ScriptMetricsScope = "https://www.googleapis.com/auth/script.metrics"

	// View Google Apps Script processes
	ScriptProcessesScope = "https://www.googleapis.com/auth/script.processes"

	// Create and update Google Apps Script projects
	ScriptProjectsScope = "https://www.googleapis.com/auth/script.projects"

	// View Google Apps Script projects
	ScriptProjectsReadonlyScope = "https://www.googleapis.com/auth/script.projects.readonly"

	// See, edit, create, and delete your spreadsheets in Google Drive
	SpreadsheetsScope = "https://www.googleapis.com/auth/spreadsheets"

	// View your email address
	UserinfoEmailScope = "https://www.googleapis.com/auth/userinfo.email"
)

    OAuth2 scopes used by this API.

    Variables

    This section is empty.

    Functions

    This section is empty.

    Types

    type Content

    type Content struct {
    	// Files: The list of script project files.
    	// One of the files is a script manifest; it must be named
    	// "appsscript",
    	// must have type of JSON, and include the manifest configurations for
    	// the
    	// project.
    	Files []*File `json:"files,omitempty"`
    
    	// ScriptId: The script project's Drive ID.
    	ScriptId string `json:"scriptId,omitempty"`
    
    	// ServerResponse contains the HTTP response code and headers from the
    	// server.
    	googleapi.ServerResponse `json:"-"`
    
    	// ForceSendFields is a list of field names (e.g. "Files") to
    	// unconditionally include in API requests. By default, fields with
    	// empty values are omitted from API requests. However, any non-pointer,
    	// non-interface field appearing in ForceSendFields will be sent to the
    	// server regardless of whether the field is empty or not. This may be
    	// used to include empty fields in Patch requests.
    	ForceSendFields []string `json:"-"`
    
    	// NullFields is a list of field names (e.g. "Files") to include in API
    	// requests with the JSON null value. By default, fields with empty
    	// values are omitted from API requests. However, any field with an
    	// empty value appearing in NullFields will be sent to the server as
    	// null. It is an error if a field in this list has a non-empty value.
    	// This may be used to include null fields in Patch requests.
    	NullFields []string `json:"-"`
    }

      Content: The Content resource.

      func (*Content) MarshalJSON

      func (s *Content) MarshalJSON() ([]byte, error)

      type CreateProjectRequest

      type CreateProjectRequest struct {
      	// ParentId: The Drive ID of a parent file that the created script
      	// project is bound to.
      	// This is usually the ID of a Google Doc, Google Sheet, Google Form,
      	// or
      	// Google Slides file. If not set, a standalone script project is
      	// created.
      	ParentId string `json:"parentId,omitempty"`
      
      	// Title: The title for the project.
      	Title string `json:"title,omitempty"`
      
      	// ForceSendFields is a list of field names (e.g. "ParentId") to
      	// unconditionally include in API requests. By default, fields with
      	// empty values are omitted from API requests. However, any non-pointer,
      	// non-interface field appearing in ForceSendFields will be sent to the
      	// server regardless of whether the field is empty or not. This may be
      	// used to include empty fields in Patch requests.
      	ForceSendFields []string `json:"-"`
      
      	// NullFields is a list of field names (e.g. "ParentId") 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:"-"`
      }

        CreateProjectRequest: Request to create a script project.

        func (*CreateProjectRequest) MarshalJSON

        func (s *CreateProjectRequest) MarshalJSON() ([]byte, error)

        type Deployment

        type Deployment struct {
        	// DeploymentConfig: The deployment configuration.
        	DeploymentConfig *DeploymentConfig `json:"deploymentConfig,omitempty"`
        
        	// DeploymentId: The deployment ID for this deployment.
        	DeploymentId string `json:"deploymentId,omitempty"`
        
        	// EntryPoints: The deployment's entry points.
        	EntryPoints []*EntryPoint `json:"entryPoints,omitempty"`
        
        	// UpdateTime: Last modified date time stamp.
        	UpdateTime string `json:"updateTime,omitempty"`
        
        	// ServerResponse contains the HTTP response code and headers from the
        	// server.
        	googleapi.ServerResponse `json:"-"`
        
        	// ForceSendFields is a list of field names (e.g. "DeploymentConfig") to
        	// unconditionally include in API requests. By default, fields with
        	// empty values are omitted from API requests. However, any non-pointer,
        	// non-interface field appearing in ForceSendFields will be sent to the
        	// server regardless of whether the field is empty or not. This may be
        	// used to include empty fields in Patch requests.
        	ForceSendFields []string `json:"-"`
        
        	// NullFields is a list of field names (e.g. "DeploymentConfig") 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:"-"`
        }

          Deployment: Representation of a single script deployment.

          func (*Deployment) MarshalJSON

          func (s *Deployment) MarshalJSON() ([]byte, error)

          type DeploymentConfig

          type DeploymentConfig struct {
          	// Description: The description for this deployment.
          	Description string `json:"description,omitempty"`
          
          	// ManifestFileName: The manifest file name for this deployment.
          	ManifestFileName string `json:"manifestFileName,omitempty"`
          
          	// ScriptId: The script project's Drive ID.
          	ScriptId string `json:"scriptId,omitempty"`
          
          	// VersionNumber: The version number on which this deployment is based.
          	VersionNumber int64 `json:"versionNumber,omitempty"`
          
          	// ForceSendFields is a list of field names (e.g. "Description") to
          	// unconditionally include in API requests. By default, fields with
          	// empty values are omitted from API requests. However, any non-pointer,
          	// non-interface field appearing in ForceSendFields will be sent to the
          	// server regardless of whether the field is empty or not. This may be
          	// used to include empty fields in Patch requests.
          	ForceSendFields []string `json:"-"`
          
          	// NullFields is a list of field names (e.g. "Description") to include
          	// in API requests with the JSON null value. By default, fields with
          	// empty values are omitted from API requests. However, any field with
          	// an empty value appearing in NullFields will be sent to the server as
          	// null. It is an error if a field in this list has a non-empty value.
          	// This may be used to include null fields in Patch requests.
          	NullFields []string `json:"-"`
          }

            DeploymentConfig: Metadata the defines how a deployment is configured.

            func (*DeploymentConfig) MarshalJSON

            func (s *DeploymentConfig) MarshalJSON() ([]byte, error)

            type Empty

            type Empty struct {
            	// ServerResponse contains the HTTP response code and headers from the
            	// server.
            	googleapi.ServerResponse `json:"-"`
            }

              Empty: A generic empty message that you can re-use to avoid defining duplicated empty messages in your APIs. A typical example is to use it as the request or the response type of an API method. For instance:

              service Foo {
                rpc Bar(google.protobuf.Empty) returns
              

              (google.protobuf.Empty);

              }
              

              The JSON representation for `Empty` is empty JSON object `{}`.

              type EntryPoint

              type EntryPoint struct {
              	// AddOn: Add-on properties.
              	AddOn *GoogleAppsScriptTypeAddOnEntryPoint `json:"addOn,omitempty"`
              
              	// EntryPointType: The type of the entry point.
              	//
              	// Possible values:
              	//   "ENTRY_POINT_TYPE_UNSPECIFIED" - An unspecified entry point.
              	//   "WEB_APP" - A web application entry point.
              	//   "EXECUTION_API" - An API executable entry point.
              	//   "ADD_ON" - An Add-On entry point.
              	EntryPointType string `json:"entryPointType,omitempty"`
              
              	// ExecutionApi: An entry point specification for Apps Script API
              	// execution calls.
              	ExecutionApi *GoogleAppsScriptTypeExecutionApiEntryPoint `json:"executionApi,omitempty"`
              
              	// WebApp: An entry point specification for web apps.
              	WebApp *GoogleAppsScriptTypeWebAppEntryPoint `json:"webApp,omitempty"`
              
              	// ForceSendFields is a list of field names (e.g. "AddOn") to
              	// unconditionally include in API requests. By default, fields with
              	// empty values are omitted from API requests. However, any non-pointer,
              	// non-interface field appearing in ForceSendFields will be sent to the
              	// server regardless of whether the field is empty or not. This may be
              	// used to include empty fields in Patch requests.
              	ForceSendFields []string `json:"-"`
              
              	// NullFields is a list of field names (e.g. "AddOn") 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:"-"`
              }

                EntryPoint: A configuration that defines how a deployment is accessed externally.

                func (*EntryPoint) MarshalJSON

                func (s *EntryPoint) MarshalJSON() ([]byte, error)

                type ExecuteStreamResponse

                type ExecuteStreamResponse struct {
                	// Result: The result of the execution.
                	// TODO (johnlattin): Add debugging and logging.
                	Result *ScriptExecutionResult `json:"result,omitempty"`
                
                	// ForceSendFields is a list of field names (e.g. "Result") to
                	// unconditionally include in API requests. By default, fields with
                	// empty values are omitted from API requests. However, any non-pointer,
                	// non-interface field appearing in ForceSendFields will be sent to the
                	// server regardless of whether the field is empty or not. This may be
                	// used to include empty fields in Patch requests.
                	ForceSendFields []string `json:"-"`
                
                	// NullFields is a list of field names (e.g. "Result") 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:"-"`
                }

                  ExecuteStreamResponse: The response for executing or debugging a function in an Apps Script project.

                  func (*ExecuteStreamResponse) MarshalJSON

                  func (s *ExecuteStreamResponse) MarshalJSON() ([]byte, error)

                  type ExecutionError

                  type ExecutionError struct {
                  	// ErrorMessage: The error message thrown by Apps Script, usually
                  	// localized into the user's
                  	// language.
                  	ErrorMessage string `json:"errorMessage,omitempty"`
                  
                  	// ErrorType: The error type, for example `TypeError` or
                  	// `ReferenceError`. If the error
                  	// type is unavailable, this field is not included.
                  	ErrorType string `json:"errorType,omitempty"`
                  
                  	// ScriptStackTraceElements: An array of objects that provide a stack
                  	// trace through the script to show
                  	// where the execution failed, with the deepest call first.
                  	ScriptStackTraceElements []*ScriptStackTraceElement `json:"scriptStackTraceElements,omitempty"`
                  
                  	// ForceSendFields is a list of field names (e.g. "ErrorMessage") to
                  	// unconditionally include in API requests. By default, fields with
                  	// empty values are omitted from API requests. However, any non-pointer,
                  	// non-interface field appearing in ForceSendFields will be sent to the
                  	// server regardless of whether the field is empty or not. This may be
                  	// used to include empty fields in Patch requests.
                  	ForceSendFields []string `json:"-"`
                  
                  	// NullFields is a list of field names (e.g. "ErrorMessage") 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:"-"`
                  }

                    ExecutionError: An object that provides information about the nature of an error resulting from an attempted execution of a script function using the Apps Script API. If a run call succeeds but the script function (or Apps Script itself) throws an exception, the response body's error field contains a Status object. The `Status` object's `details` field contains an array with a single one of these `ExecutionError` objects.

                    func (*ExecutionError) MarshalJSON

                    func (s *ExecutionError) MarshalJSON() ([]byte, error)

                    type ExecutionRequest

                    type ExecutionRequest struct {
                    	// DevMode: If `true` and the user is an owner of the script, the script
                    	// runs at the
                    	// most recently saved version rather than the version deployed for use
                    	// with
                    	// the Apps Script API. Optional; default is `false`.
                    	DevMode bool `json:"devMode,omitempty"`
                    
                    	// Function: The name of the function to execute in the given script.
                    	// The name does not
                    	// include parentheses or parameters. It can reference a function in
                    	// an
                    	// included library such as `Library.libFunction1`.
                    	Function string `json:"function,omitempty"`
                    
                    	// Parameters: The parameters to be passed to the function being
                    	// executed. The object type
                    	// for each parameter should match the expected type in Apps
                    	// Script.
                    	// Parameters cannot be Apps Script-specific object types (such as
                    	// a
                    	// `Document` or a `Calendar`); they can only be primitive types such
                    	// as
                    	// `string`, `number`, `array`, `object`, or `boolean`. Optional.
                    	Parameters []interface{} `json:"parameters,omitempty"`
                    
                    	// SessionState: <b>Deprecated</b>. For use with Android add-ons only.
                    	// An ID that represents
                    	// the user's current session in the Android app for Google Docs or
                    	// Sheets,
                    	// included as extra data in
                    	// the
                    	// [Intent](https://developer.android.com/guide/components/intents-fi
                    	// lters.html)
                    	// that launches the add-on. When an Android add-on is run with a
                    	// session
                    	// state, it gains the privileges of
                    	// a
                    	// [bound](https://developers.google.com/apps-script/guides/bound)
                    	// scri
                    	// pt&mdash;that is, it can access information like the user's
                    	// current
                    	// cursor position (in Docs) or selected cell (in Sheets). To retrieve
                    	// the
                    	// state,
                    	// call
                    	// `Intent.getStringExtra("com.google.android.apps.docs.addons.Sessi
                    	// onState")`.
                    	// Optional.
                    	SessionState string `json:"sessionState,omitempty"`
                    
                    	// ForceSendFields is a list of field names (e.g. "DevMode") to
                    	// unconditionally include in API requests. By default, fields with
                    	// empty values are omitted from API requests. However, any non-pointer,
                    	// non-interface field appearing in ForceSendFields will be sent to the
                    	// server regardless of whether the field is empty or not. This may be
                    	// used to include empty fields in Patch requests.
                    	ForceSendFields []string `json:"-"`
                    
                    	// NullFields is a list of field names (e.g. "DevMode") 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:"-"`
                    }

                      ExecutionRequest: A request to run the function in a script. The script is identified by the specified `script_id`. Executing a function on a script returns results based on the implementation of the script.

                      func (*ExecutionRequest) MarshalJSON

                      func (s *ExecutionRequest) MarshalJSON() ([]byte, error)

                      type ExecutionResponse

                      type ExecutionResponse struct {
                      	// Result: The return value of the script function. The type matches the
                      	// object type
                      	// returned in Apps Script. Functions called using the Apps Script API
                      	// cannot
                      	// return Apps Script-specific objects (such as a `Document` or a
                      	// `Calendar`);
                      	// they can only return primitive types such as a `string`, `number`,
                      	// `array`,
                      	// `object`, or `boolean`.
                      	Result interface{} `json:"result,omitempty"`
                      
                      	// ForceSendFields is a list of field names (e.g. "Result") to
                      	// unconditionally include in API requests. By default, fields with
                      	// empty values are omitted from API requests. However, any non-pointer,
                      	// non-interface field appearing in ForceSendFields will be sent to the
                      	// server regardless of whether the field is empty or not. This may be
                      	// used to include empty fields in Patch requests.
                      	ForceSendFields []string `json:"-"`
                      
                      	// NullFields is a list of field names (e.g. "Result") 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:"-"`
                      }

                        ExecutionResponse: An object that provides the return value of a function executed using the Apps Script API. If the script function returns successfully, the response body's response field contains this `ExecutionResponse` object.

                        func (*ExecutionResponse) MarshalJSON

                        func (s *ExecutionResponse) MarshalJSON() ([]byte, error)

                        type File

                        type File struct {
                        	// CreateTime: Creation date timestamp.
                        	// This read-only field is only visible to users who have
                        	// WRITER
                        	// permission for the script project.
                        	CreateTime string `json:"createTime,omitempty"`
                        
                        	// FunctionSet: The defined set of functions in the script file, if any.
                        	FunctionSet *GoogleAppsScriptTypeFunctionSet `json:"functionSet,omitempty"`
                        
                        	// LastModifyUser: The user who modified the file most recently.
                        	// This read-only field is only visible to users who have
                        	// WRITER
                        	// permission for the script project.
                        	LastModifyUser *GoogleAppsScriptTypeUser `json:"lastModifyUser,omitempty"`
                        
                        	// Name: The name of the file. The file extension is not part of the
                        	// file
                        	// name, which can be identified from the type field.
                        	Name string `json:"name,omitempty"`
                        
                        	// Source: The file content.
                        	Source string `json:"source,omitempty"`
                        
                        	// Type: The type of the file.
                        	//
                        	// Possible values:
                        	//   "ENUM_TYPE_UNSPECIFIED" - Undetermined file type; never actually
                        	// used.
                        	//   "SERVER_JS" - An Apps Script server-side code file.
                        	//   "HTML" - A file containing client-side HTML.
                        	//   "JSON" - A file in JSON format. This type is only used for the
                        	// script
                        	// project's manifest. The manifest file content must match
                        	// the
                        	// structure of a
                        	// valid
                        	// [ScriptManifest](/apps-script/concepts/manifests)
                        	Type string `json:"type,omitempty"`
                        
                        	// UpdateTime: Last modified date timestamp.
                        	// This read-only field is only visible to users who have
                        	// WRITER
                        	// permission for the script project.
                        	UpdateTime string `json:"updateTime,omitempty"`
                        
                        	// ForceSendFields is a list of field names (e.g. "CreateTime") to
                        	// unconditionally include in API requests. By default, fields with
                        	// empty values are omitted from API requests. However, any non-pointer,
                        	// non-interface field appearing in ForceSendFields will be sent to the
                        	// server regardless of whether the field is empty or not. This may be
                        	// used to include empty fields in Patch requests.
                        	ForceSendFields []string `json:"-"`
                        
                        	// NullFields is a list of field names (e.g. "CreateTime") 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:"-"`
                        }

                          File: An individual file within a script project. A file is a third-party source code created by one or more developers. It can be a server-side JS code, HTML, or a configuration file. Each script project can contain multiple files.

                          func (*File) MarshalJSON

                          func (s *File) MarshalJSON() ([]byte, error)

                          type GoogleAppsScriptTypeAddOnEntryPoint

                          type GoogleAppsScriptTypeAddOnEntryPoint struct {
                          	// AddOnType: The add-on's required list of supported container types.
                          	//
                          	// Possible values:
                          	//   "UNKNOWN_ADDON_TYPE" - Default value, unknown add-on type.
                          	//   "GMAIL" - Add-on type for Gmail.
                          	//   "DATA_STUDIO" - Add-on type for Data Studio.
                          	AddOnType string `json:"addOnType,omitempty"`
                          
                          	// Description: The add-on's optional description.
                          	Description string `json:"description,omitempty"`
                          
                          	// HelpUrl: The add-on's optional help URL.
                          	HelpUrl string `json:"helpUrl,omitempty"`
                          
                          	// PostInstallTipUrl: The add-on's required post install tip URL.
                          	PostInstallTipUrl string `json:"postInstallTipUrl,omitempty"`
                          
                          	// ReportIssueUrl: The add-on's optional report issue URL.
                          	ReportIssueUrl string `json:"reportIssueUrl,omitempty"`
                          
                          	// Title: The add-on's required title.
                          	Title string `json:"title,omitempty"`
                          
                          	// ForceSendFields is a list of field names (e.g. "AddOnType") to
                          	// unconditionally include in API requests. By default, fields with
                          	// empty values are omitted from API requests. However, any non-pointer,
                          	// non-interface field appearing in ForceSendFields will be sent to the
                          	// server regardless of whether the field is empty or not. This may be
                          	// used to include empty fields in Patch requests.
                          	ForceSendFields []string `json:"-"`
                          
                          	// NullFields is a list of field names (e.g. "AddOnType") 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:"-"`
                          }

                            GoogleAppsScriptTypeAddOnEntryPoint: An add-on entry point.

                            func (*GoogleAppsScriptTypeAddOnEntryPoint) MarshalJSON

                            func (s *GoogleAppsScriptTypeAddOnEntryPoint) MarshalJSON() ([]byte, error)

                            type GoogleAppsScriptTypeExecutionApiConfig

                            type GoogleAppsScriptTypeExecutionApiConfig struct {
                            	// Access: Who has permission to run the API executable.
                            	//
                            	// Possible values:
                            	//   "UNKNOWN_ACCESS" - Default value, should not be used.
                            	//   "MYSELF" - Only the user who deployed the web app or executable can
                            	// access it.
                            	// Note that this is not necessarily the owner of the script project.
                            	//   "DOMAIN" - Only users in the same domain as the user who deployed
                            	// the web app or
                            	// executable can access it.
                            	//   "ANYONE" - Any logged in user can access the web app or executable.
                            	//   "ANYONE_ANONYMOUS" - Any user, logged in or not, can access the web
                            	// app or executable.
                            	Access string `json:"access,omitempty"`
                            
                            	// ForceSendFields is a list of field names (e.g. "Access") to
                            	// unconditionally include in API requests. By default, fields with
                            	// empty values are omitted from API requests. However, any non-pointer,
                            	// non-interface field appearing in ForceSendFields will be sent to the
                            	// server regardless of whether the field is empty or not. This may be
                            	// used to include empty fields in Patch requests.
                            	ForceSendFields []string `json:"-"`
                            
                            	// NullFields is a list of field names (e.g. "Access") 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:"-"`
                            }

                              GoogleAppsScriptTypeExecutionApiConfig: API executable entry point configuration.

                              func (*GoogleAppsScriptTypeExecutionApiConfig) MarshalJSON

                              func (s *GoogleAppsScriptTypeExecutionApiConfig) MarshalJSON() ([]byte, error)

                              type GoogleAppsScriptTypeExecutionApiEntryPoint

                              type GoogleAppsScriptTypeExecutionApiEntryPoint struct {
                              	// EntryPointConfig: The entry point's configuration.
                              	EntryPointConfig *GoogleAppsScriptTypeExecutionApiConfig `json:"entryPointConfig,omitempty"`
                              
                              	// ForceSendFields is a list of field names (e.g. "EntryPointConfig") to
                              	// unconditionally include in API requests. By default, fields with
                              	// empty values are omitted from API requests. However, any non-pointer,
                              	// non-interface field appearing in ForceSendFields will be sent to the
                              	// server regardless of whether the field is empty or not. This may be
                              	// used to include empty fields in Patch requests.
                              	ForceSendFields []string `json:"-"`
                              
                              	// NullFields is a list of field names (e.g. "EntryPointConfig") 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:"-"`
                              }

                                GoogleAppsScriptTypeExecutionApiEntryPoint: An API executable entry point.

                                func (*GoogleAppsScriptTypeExecutionApiEntryPoint) MarshalJSON

                                type GoogleAppsScriptTypeFunction

                                type GoogleAppsScriptTypeFunction struct {
                                	// Name: The function name in the script project.
                                	Name string `json:"name,omitempty"`
                                
                                	// ForceSendFields is a list of field names (e.g. "Name") to
                                	// unconditionally include in API requests. By default, fields with
                                	// empty values are omitted from API requests. However, any non-pointer,
                                	// non-interface field appearing in ForceSendFields will be sent to the
                                	// server regardless of whether the field is empty or not. This may be
                                	// used to include empty fields in Patch requests.
                                	ForceSendFields []string `json:"-"`
                                
                                	// NullFields is a list of field names (e.g. "Name") to include in API
                                	// requests with the JSON null value. By default, fields with empty
                                	// values are omitted from API requests. However, any field with an
                                	// empty value appearing in NullFields will be sent to the server as
                                	// null. It is an error if a field in this list has a non-empty value.
                                	// This may be used to include null fields in Patch requests.
                                	NullFields []string `json:"-"`
                                }

                                  GoogleAppsScriptTypeFunction: Represents a function in a script project.

                                  func (*GoogleAppsScriptTypeFunction) MarshalJSON

                                  func (s *GoogleAppsScriptTypeFunction) MarshalJSON() ([]byte, error)

                                  type GoogleAppsScriptTypeFunctionSet

                                  type GoogleAppsScriptTypeFunctionSet struct {
                                  	// Values: A list of functions composing the set.
                                  	Values []*GoogleAppsScriptTypeFunction `json:"values,omitempty"`
                                  
                                  	// ForceSendFields is a list of field names (e.g. "Values") to
                                  	// unconditionally include in API requests. By default, fields with
                                  	// empty values are omitted from API requests. However, any non-pointer,
                                  	// non-interface field appearing in ForceSendFields will be sent to the
                                  	// server regardless of whether the field is empty or not. This may be
                                  	// used to include empty fields in Patch requests.
                                  	ForceSendFields []string `json:"-"`
                                  
                                  	// NullFields is a list of field names (e.g. "Values") 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:"-"`
                                  }

                                    GoogleAppsScriptTypeFunctionSet: A set of functions. No duplicates are permitted.

                                    func (*GoogleAppsScriptTypeFunctionSet) MarshalJSON

                                    func (s *GoogleAppsScriptTypeFunctionSet) MarshalJSON() ([]byte, error)

                                    type GoogleAppsScriptTypeProcess

                                    type GoogleAppsScriptTypeProcess struct {
                                    	// Duration: Duration the execution spent executing.
                                    	Duration string `json:"duration,omitempty"`
                                    
                                    	// FunctionName: Name of the function the started the execution.
                                    	FunctionName string `json:"functionName,omitempty"`
                                    
                                    	// ProcessStatus: The executions status.
                                    	//
                                    	// Possible values:
                                    	//   "PROCESS_STATUS_UNSPECIFIED" - Unspecified status.
                                    	//   "RUNNING" - The process is currently running.
                                    	//   "PAUSED" - The process has paused.
                                    	//   "COMPLETED" - The process has completed.
                                    	//   "CANCELED" - The process was cancelled.
                                    	//   "FAILED" - The process failed.
                                    	//   "TIMED_OUT" - The process timed out.
                                    	//   "UNKNOWN" - Process status unknown.
                                    	//   "DELAYED" - The process is delayed, waiting for quota.
                                    	ProcessStatus string `json:"processStatus,omitempty"`
                                    
                                    	// ProcessType: The executions type.
                                    	//
                                    	// Possible values:
                                    	//   "PROCESS_TYPE_UNSPECIFIED" - Unspecified type.
                                    	//   "ADD_ON" - The process was started from an add-on entry point.
                                    	//   "EXECUTION_API" - The process was started using the Apps Script
                                    	// API.
                                    	//   "TIME_DRIVEN" - The process was started from a time-based trigger.
                                    	//   "TRIGGER" - The process was started from an event-based trigger.
                                    	//   "WEBAPP" - The process was started from a web app entry point.
                                    	//   "EDITOR" - The process was started using the Apps Script IDE.
                                    	//   "SIMPLE_TRIGGER" - The process was started from a G Suite simple
                                    	// trigger.
                                    	//   "MENU" - The process was started from a G Suite menu item.
                                    	//   "BATCH_TASK" - The process was started as a task in a batch job.
                                    	ProcessType string `json:"processType,omitempty"`
                                    
                                    	// ProjectName: Name of the script being executed.
                                    	ProjectName string `json:"projectName,omitempty"`
                                    
                                    	// StartTime: Time the execution started.
                                    	StartTime string `json:"startTime,omitempty"`
                                    
                                    	// UserAccessLevel: The executing users access level to the script.
                                    	//
                                    	// Possible values:
                                    	//   "USER_ACCESS_LEVEL_UNSPECIFIED" - User access level unspecified
                                    	//   "NONE" - The user has no access.
                                    	//   "READ" - The user has read-only access.
                                    	//   "WRITE" - The user has write access.
                                    	//   "OWNER" - The user is an owner.
                                    	UserAccessLevel string `json:"userAccessLevel,omitempty"`
                                    
                                    	// ForceSendFields is a list of field names (e.g. "Duration") to
                                    	// unconditionally include in API requests. By default, fields with
                                    	// empty values are omitted from API requests. However, any non-pointer,
                                    	// non-interface field appearing in ForceSendFields will be sent to the
                                    	// server regardless of whether the field is empty or not. This may be
                                    	// used to include empty fields in Patch requests.
                                    	ForceSendFields []string `json:"-"`
                                    
                                    	// NullFields is a list of field names (e.g. "Duration") 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:"-"`
                                    }

                                      GoogleAppsScriptTypeProcess: Representation of a single script process execution that was started from the script editor, a trigger, an application, or using the Apps Script API. This is distinct from the `Operation` resource, which only represents executions started via the Apps Script API.

                                      func (*GoogleAppsScriptTypeProcess) MarshalJSON

                                      func (s *GoogleAppsScriptTypeProcess) MarshalJSON() ([]byte, error)

                                      type GoogleAppsScriptTypeUser

                                      type GoogleAppsScriptTypeUser struct {
                                      	// Domain: The user's domain.
                                      	Domain string `json:"domain,omitempty"`
                                      
                                      	// Email: The user's identifying email address.
                                      	Email string `json:"email,omitempty"`
                                      
                                      	// Name: The user's display name.
                                      	Name string `json:"name,omitempty"`
                                      
                                      	// PhotoUrl: The user's photo.
                                      	PhotoUrl string `json:"photoUrl,omitempty"`
                                      
                                      	// ForceSendFields is a list of field names (e.g. "Domain") to
                                      	// unconditionally include in API requests. By default, fields with
                                      	// empty values are omitted from API requests. However, any non-pointer,
                                      	// non-interface field appearing in ForceSendFields will be sent to the
                                      	// server regardless of whether the field is empty or not. This may be
                                      	// used to include empty fields in Patch requests.
                                      	ForceSendFields []string `json:"-"`
                                      
                                      	// NullFields is a list of field names (e.g. "Domain") 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:"-"`
                                      }

                                        GoogleAppsScriptTypeUser: A simple user profile resource.

                                        func (*GoogleAppsScriptTypeUser) MarshalJSON

                                        func (s *GoogleAppsScriptTypeUser) MarshalJSON() ([]byte, error)

                                        type GoogleAppsScriptTypeWebAppConfig

                                        type GoogleAppsScriptTypeWebAppConfig struct {
                                        	// Access: Who has permission to run the web app.
                                        	//
                                        	// Possible values:
                                        	//   "UNKNOWN_ACCESS" - Default value, should not be used.
                                        	//   "MYSELF" - Only the user who deployed the web app or executable can
                                        	// access it.
                                        	// Note that this is not necessarily the owner of the script project.
                                        	//   "DOMAIN" - Only users in the same domain as the user who deployed
                                        	// the web app or
                                        	// executable can access it.
                                        	//   "ANYONE" - Any logged in user can access the web app or executable.
                                        	//   "ANYONE_ANONYMOUS" - Any user, logged in or not, can access the web
                                        	// app or executable.
                                        	Access string `json:"access,omitempty"`
                                        
                                        	// ExecuteAs: Who to execute the web app as.
                                        	//
                                        	// Possible values:
                                        	//   "UNKNOWN_EXECUTE_AS" - Default value, should not be used.
                                        	//   "USER_ACCESSING" - The script runs as the user accessing the web
                                        	// app.
                                        	//   "USER_DEPLOYING" - The script runs as the user who deployed the web
                                        	// app. Note that this is
                                        	// not necessarily the owner of the script project.
                                        	ExecuteAs string `json:"executeAs,omitempty"`
                                        
                                        	// ForceSendFields is a list of field names (e.g. "Access") to
                                        	// unconditionally include in API requests. By default, fields with
                                        	// empty values are omitted from API requests. However, any non-pointer,
                                        	// non-interface field appearing in ForceSendFields will be sent to the
                                        	// server regardless of whether the field is empty or not. This may be
                                        	// used to include empty fields in Patch requests.
                                        	ForceSendFields []string `json:"-"`
                                        
                                        	// NullFields is a list of field names (e.g. "Access") 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:"-"`
                                        }

                                          GoogleAppsScriptTypeWebAppConfig: Web app entry point configuration.

                                          func (*GoogleAppsScriptTypeWebAppConfig) MarshalJSON

                                          func (s *GoogleAppsScriptTypeWebAppConfig) MarshalJSON() ([]byte, error)

                                          type GoogleAppsScriptTypeWebAppEntryPoint

                                          type GoogleAppsScriptTypeWebAppEntryPoint struct {
                                          	// EntryPointConfig: The entry point's configuration.
                                          	EntryPointConfig *GoogleAppsScriptTypeWebAppConfig `json:"entryPointConfig,omitempty"`
                                          
                                          	// Url: The URL for the web application.
                                          	Url string `json:"url,omitempty"`
                                          
                                          	// ForceSendFields is a list of field names (e.g. "EntryPointConfig") to
                                          	// unconditionally include in API requests. By default, fields with
                                          	// empty values are omitted from API requests. However, any non-pointer,
                                          	// non-interface field appearing in ForceSendFields will be sent to the
                                          	// server regardless of whether the field is empty or not. This may be
                                          	// used to include empty fields in Patch requests.
                                          	ForceSendFields []string `json:"-"`
                                          
                                          	// NullFields is a list of field names (e.g. "EntryPointConfig") 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:"-"`
                                          }

                                            GoogleAppsScriptTypeWebAppEntryPoint: A web application entry point.

                                            func (*GoogleAppsScriptTypeWebAppEntryPoint) MarshalJSON

                                            func (s *GoogleAppsScriptTypeWebAppEntryPoint) MarshalJSON() ([]byte, error)

                                            type ListDeploymentsResponse

                                            type ListDeploymentsResponse struct {
                                            	// Deployments: The list of deployments.
                                            	Deployments []*Deployment `json:"deployments,omitempty"`
                                            
                                            	// NextPageToken: The token that can be used in the next call to get the
                                            	// next page of
                                            	// results.
                                            	NextPageToken string `json:"nextPageToken,omitempty"`
                                            
                                            	// ServerResponse contains the HTTP response code and headers from the
                                            	// server.
                                            	googleapi.ServerResponse `json:"-"`
                                            
                                            	// ForceSendFields is a list of field names (e.g. "Deployments") to
                                            	// unconditionally include in API requests. By default, fields with
                                            	// empty values are omitted from API requests. However, any non-pointer,
                                            	// non-interface field appearing in ForceSendFields will be sent to the
                                            	// server regardless of whether the field is empty or not. This may be
                                            	// used to include empty fields in Patch requests.
                                            	ForceSendFields []string `json:"-"`
                                            
                                            	// NullFields is a list of field names (e.g. "Deployments") 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:"-"`
                                            }

                                              ListDeploymentsResponse: Response with the list of deployments for the specified Apps Script project.

                                              func (*ListDeploymentsResponse) MarshalJSON

                                              func (s *ListDeploymentsResponse) MarshalJSON() ([]byte, error)

                                              type ListScriptProcessesResponse

                                              type ListScriptProcessesResponse struct {
                                              	// NextPageToken: Token for the next page of results. If empty, there
                                              	// are no more pages
                                              	// remaining.
                                              	NextPageToken string `json:"nextPageToken,omitempty"`
                                              
                                              	// Processes: List of processes matching request parameters.
                                              	Processes []*GoogleAppsScriptTypeProcess `json:"processes,omitempty"`
                                              
                                              	// ServerResponse contains the HTTP response code and headers from the
                                              	// server.
                                              	googleapi.ServerResponse `json:"-"`
                                              
                                              	// ForceSendFields is a list of field names (e.g. "NextPageToken") to
                                              	// unconditionally include in API requests. By default, fields with
                                              	// empty values are omitted from API requests. However, any non-pointer,
                                              	// non-interface field appearing in ForceSendFields will be sent to the
                                              	// server regardless of whether the field is empty or not. This may be
                                              	// used to include empty fields in Patch requests.
                                              	ForceSendFields []string `json:"-"`
                                              
                                              	// NullFields is a list of field names (e.g. "NextPageToken") to include
                                              	// in API requests with the JSON null value. By default, fields with
                                              	// empty values are omitted from API requests. However, any field with
                                              	// an empty value appearing in NullFields will be sent to the server as
                                              	// null. It is an error if a field in this list has a non-empty value.
                                              	// This may be used to include null fields in Patch requests.
                                              	NullFields []string `json:"-"`
                                              }

                                                ListScriptProcessesResponse: Response with the list of Process resources.

                                                func (*ListScriptProcessesResponse) MarshalJSON

                                                func (s *ListScriptProcessesResponse) MarshalJSON() ([]byte, error)

                                                type ListUserProcessesResponse

                                                type ListUserProcessesResponse struct {
                                                	// NextPageToken: Token for the next page of results. If empty, there
                                                	// are no more pages
                                                	// remaining.
                                                	NextPageToken string `json:"nextPageToken,omitempty"`
                                                
                                                	// Processes: List of processes matching request parameters.
                                                	Processes []*GoogleAppsScriptTypeProcess `json:"processes,omitempty"`
                                                
                                                	// ServerResponse contains the HTTP response code and headers from the
                                                	// server.
                                                	googleapi.ServerResponse `json:"-"`
                                                
                                                	// ForceSendFields is a list of field names (e.g. "NextPageToken") to
                                                	// unconditionally include in API requests. By default, fields with
                                                	// empty values are omitted from API requests. However, any non-pointer,
                                                	// non-interface field appearing in ForceSendFields will be sent to the
                                                	// server regardless of whether the field is empty or not. This may be
                                                	// used to include empty fields in Patch requests.
                                                	ForceSendFields []string `json:"-"`
                                                
                                                	// NullFields is a list of field names (e.g. "NextPageToken") to include
                                                	// in API requests with the JSON null value. By default, fields with
                                                	// empty values are omitted from API requests. However, any field with
                                                	// an empty value appearing in NullFields will be sent to the server as
                                                	// null. It is an error if a field in this list has a non-empty value.
                                                	// This may be used to include null fields in Patch requests.
                                                	NullFields []string `json:"-"`
                                                }

                                                  ListUserProcessesResponse: Response with the list of Process resources.

                                                  func (*ListUserProcessesResponse) MarshalJSON

                                                  func (s *ListUserProcessesResponse) MarshalJSON() ([]byte, error)

                                                  type ListValue

                                                  type ListValue struct {
                                                  	// Values: Repeated field of dynamically typed values.
                                                  	Values []*Value `json:"values,omitempty"`
                                                  
                                                  	// ForceSendFields is a list of field names (e.g. "Values") to
                                                  	// unconditionally include in API requests. By default, fields with
                                                  	// empty values are omitted from API requests. However, any non-pointer,
                                                  	// non-interface field appearing in ForceSendFields will be sent to the
                                                  	// server regardless of whether the field is empty or not. This may be
                                                  	// used to include empty fields in Patch requests.
                                                  	ForceSendFields []string `json:"-"`
                                                  
                                                  	// NullFields is a list of field names (e.g. "Values") 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:"-"`
                                                  }

                                                    ListValue: `ListValue` is a wrapper around a repeated field of values. Based on LustValue at: google3/apps/maestro/api/struct.proto?q=message%5c%20ListValue

                                                    func (*ListValue) MarshalJSON

                                                    func (s *ListValue) MarshalJSON() ([]byte, error)

                                                    type ListVersionsResponse

                                                    type ListVersionsResponse struct {
                                                    	// NextPageToken: The token use to fetch the next page of records. if
                                                    	// not exist in the
                                                    	// response, that means no more versions to list.
                                                    	NextPageToken string `json:"nextPageToken,omitempty"`
                                                    
                                                    	// Versions: The list of versions.
                                                    	Versions []*Version `json:"versions,omitempty"`
                                                    
                                                    	// ServerResponse contains the HTTP response code and headers from the
                                                    	// server.
                                                    	googleapi.ServerResponse `json:"-"`
                                                    
                                                    	// ForceSendFields is a list of field names (e.g. "NextPageToken") to
                                                    	// unconditionally include in API requests. By default, fields with
                                                    	// empty values are omitted from API requests. However, any non-pointer,
                                                    	// non-interface field appearing in ForceSendFields will be sent to the
                                                    	// server regardless of whether the field is empty or not. This may be
                                                    	// used to include empty fields in Patch requests.
                                                    	ForceSendFields []string `json:"-"`
                                                    
                                                    	// NullFields is a list of field names (e.g. "NextPageToken") to include
                                                    	// in API requests with the JSON null value. By default, fields with
                                                    	// empty values are omitted from API requests. However, any field with
                                                    	// an empty value appearing in NullFields will be sent to the server as
                                                    	// null. It is an error if a field in this list has a non-empty value.
                                                    	// This may be used to include null fields in Patch requests.
                                                    	NullFields []string `json:"-"`
                                                    }

                                                      ListVersionsResponse: Response with the list of the versions for the specified script project.

                                                      func (*ListVersionsResponse) MarshalJSON

                                                      func (s *ListVersionsResponse) MarshalJSON() ([]byte, error)

                                                      type Metrics

                                                      type Metrics struct {
                                                      	// ActiveUsers: Number of active users.
                                                      	ActiveUsers []*MetricsValue `json:"activeUsers,omitempty"`
                                                      
                                                      	// FailedExecutions: Number of failed executions.
                                                      	FailedExecutions []*MetricsValue `json:"failedExecutions,omitempty"`
                                                      
                                                      	// TotalExecutions: Number of total executions.
                                                      	TotalExecutions []*MetricsValue `json:"totalExecutions,omitempty"`
                                                      
                                                      	// ServerResponse contains the HTTP response code and headers from the
                                                      	// server.
                                                      	googleapi.ServerResponse `json:"-"`
                                                      
                                                      	// ForceSendFields is a list of field names (e.g. "ActiveUsers") to
                                                      	// unconditionally include in API requests. By default, fields with
                                                      	// empty values are omitted from API requests. However, any non-pointer,
                                                      	// non-interface field appearing in ForceSendFields will be sent to the
                                                      	// server regardless of whether the field is empty or not. This may be
                                                      	// used to include empty fields in Patch requests.
                                                      	ForceSendFields []string `json:"-"`
                                                      
                                                      	// NullFields is a list of field names (e.g. "ActiveUsers") 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:"-"`
                                                      }

                                                        Metrics: Resource containing usage stats for a given script, based on the supplied filter and mask present in the request.

                                                        func (*Metrics) MarshalJSON

                                                        func (s *Metrics) MarshalJSON() ([]byte, error)

                                                        type MetricsValue

                                                        type MetricsValue struct {
                                                        	// EndTime: Required field indicating the end time of the interval.
                                                        	EndTime string `json:"endTime,omitempty"`
                                                        
                                                        	// StartTime: Required field indicating the start time of the interval.
                                                        	StartTime string `json:"startTime,omitempty"`
                                                        
                                                        	// Value: Indicates the number of executions counted.
                                                        	Value uint64 `json:"value,omitempty,string"`
                                                        
                                                        	// ForceSendFields is a list of field names (e.g. "EndTime") to
                                                        	// unconditionally include in API requests. By default, fields with
                                                        	// empty values are omitted from API requests. However, any non-pointer,
                                                        	// non-interface field appearing in ForceSendFields will be sent to the
                                                        	// server regardless of whether the field is empty or not. This may be
                                                        	// used to include empty fields in Patch requests.
                                                        	ForceSendFields []string `json:"-"`
                                                        
                                                        	// NullFields is a list of field names (e.g. "EndTime") 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:"-"`
                                                        }

                                                          MetricsValue: Metrics value that holds number of executions counted.

                                                          func (*MetricsValue) MarshalJSON

                                                          func (s *MetricsValue) MarshalJSON() ([]byte, error)

                                                          type Operation

                                                          type Operation struct {
                                                          	// Done: This field indicates whether the script execution has
                                                          	// completed. A completed execution has a populated `response` field
                                                          	// containing the ExecutionResponse from function that was executed.
                                                          	Done bool `json:"done,omitempty"`
                                                          
                                                          	// Error: If a `run` call succeeds but the script function (or Apps
                                                          	// Script itself) throws an exception, this field contains a Status
                                                          	// object. The `Status` object's `details` field contains an array with
                                                          	// a single ExecutionError object that provides information about the
                                                          	// nature of the error.
                                                          	Error *Status `json:"error,omitempty"`
                                                          
                                                          	// Response: If the script function returns successfully, this field
                                                          	// contains an ExecutionResponse object with the function's return
                                                          	// value.
                                                          	Response googleapi.RawMessage `json:"response,omitempty"`
                                                          
                                                          	// ServerResponse contains the HTTP response code and headers from the
                                                          	// server.
                                                          	googleapi.ServerResponse `json:"-"`
                                                          
                                                          	// ForceSendFields is a list of field names (e.g. "Done") to
                                                          	// unconditionally include in API requests. By default, fields with
                                                          	// empty values are omitted from API requests. However, any non-pointer,
                                                          	// non-interface field appearing in ForceSendFields will be sent to the
                                                          	// server regardless of whether the field is empty or not. This may be
                                                          	// used to include empty fields in Patch requests.
                                                          	ForceSendFields []string `json:"-"`
                                                          
                                                          	// NullFields is a list of field names (e.g. "Done") 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:"-"`
                                                          }

                                                            Operation: A representation of an execution of an Apps Script function started with run. The execution response does not arrive until the function finishes executing. The maximum execution runtime is listed in the [Apps Script quotas guide](/apps-script/guides/services/quotas#current_limitations). <p>After execution has started, it can have one of four outcomes:</p> <ul> <li> If the script function returns successfully, the

                                                            response field contains an
                                                            ExecutionResponse object
                                                            with the function's return value in the object's `result`
                                                            

                                                            field.</li> <li> If the script function (or Apps Script itself) throws an exception, the

                                                            error field contains a
                                                            Status object. The `Status` object's `details`
                                                            field contains an array with a single
                                                            ExecutionError object that
                                                            provides information about the nature of the error.</li>
                                                            

                                                            <li> If the execution has not yet completed,

                                                            the done field is `false` and
                                                            the neither the `response` nor `error` fields are
                                                            

                                                            present.</li> <li> If the `run` call itself fails (for example, because of a

                                                            malformed request or an authorization error), the method returns an
                                                            

                                                            HTTP

                                                            response code in the 4XX range with a different format for the
                                                            

                                                            response

                                                            body. Client libraries automatically convert a 4XX response into
                                                            

                                                            an

                                                            exception class.</li>
                                                            

                                                            </ul>

                                                            func (*Operation) MarshalJSON

                                                            func (s *Operation) MarshalJSON() ([]byte, error)

                                                            type ProcessesListCall

                                                            type ProcessesListCall struct {
                                                            	// contains filtered or unexported fields
                                                            }

                                                            func (*ProcessesListCall) Context

                                                              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 (*ProcessesListCall) Do

                                                                Do executes the "script.processes.list" call. Exactly one of *ListUserProcessesResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *ListUserProcessesResponse.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 (*ProcessesListCall) Fields

                                                                  Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                  func (*ProcessesListCall) Header

                                                                  func (c *ProcessesListCall) Header() http.Header

                                                                    Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                    func (*ProcessesListCall) IfNoneMatch

                                                                    func (c *ProcessesListCall) IfNoneMatch(entityTag string) *ProcessesListCall

                                                                      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 (*ProcessesListCall) PageSize

                                                                      func (c *ProcessesListCall) PageSize(pageSize int64) *ProcessesListCall

                                                                        PageSize sets the optional parameter "pageSize": The maximum number of returned processes per page of results. Defaults to 50.

                                                                        func (*ProcessesListCall) PageToken

                                                                        func (c *ProcessesListCall) PageToken(pageToken string) *ProcessesListCall

                                                                          PageToken sets the optional parameter "pageToken": The token for continuing a previous list request on the next page. This should be set to the value of `nextPageToken` from a previous response.

                                                                          func (*ProcessesListCall) Pages

                                                                            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 (*ProcessesListCall) UserProcessFilterDeploymentId

                                                                            func (c *ProcessesListCall) UserProcessFilterDeploymentId(userProcessFilterDeploymentId string) *ProcessesListCall

                                                                              UserProcessFilterDeploymentId sets the optional parameter "userProcessFilter.deploymentId": Optional field used to limit returned processes to those originating from projects with a specific deployment ID.

                                                                              func (*ProcessesListCall) UserProcessFilterEndTime

                                                                              func (c *ProcessesListCall) UserProcessFilterEndTime(userProcessFilterEndTime string) *ProcessesListCall

                                                                                UserProcessFilterEndTime sets the optional parameter "userProcessFilter.endTime": Optional field used to limit returned processes to those that completed on or before the given timestamp.

                                                                                func (*ProcessesListCall) UserProcessFilterFunctionName

                                                                                func (c *ProcessesListCall) UserProcessFilterFunctionName(userProcessFilterFunctionName string) *ProcessesListCall

                                                                                  UserProcessFilterFunctionName sets the optional parameter "userProcessFilter.functionName": Optional field used to limit returned processes to those originating from a script function with the given function name.

                                                                                  func (*ProcessesListCall) UserProcessFilterProjectName

                                                                                  func (c *ProcessesListCall) UserProcessFilterProjectName(userProcessFilterProjectName string) *ProcessesListCall

                                                                                    UserProcessFilterProjectName sets the optional parameter "userProcessFilter.projectName": Optional field used to limit returned processes to those originating from projects with project names containing a specific string.

                                                                                    func (*ProcessesListCall) UserProcessFilterScriptId

                                                                                    func (c *ProcessesListCall) UserProcessFilterScriptId(userProcessFilterScriptId string) *ProcessesListCall

                                                                                      UserProcessFilterScriptId sets the optional parameter "userProcessFilter.scriptId": Optional field used to limit returned processes to those originating from projects with a specific script ID.

                                                                                      func (*ProcessesListCall) UserProcessFilterStartTime

                                                                                      func (c *ProcessesListCall) UserProcessFilterStartTime(userProcessFilterStartTime string) *ProcessesListCall

                                                                                        UserProcessFilterStartTime sets the optional parameter "userProcessFilter.startTime": Optional field used to limit returned processes to those that were started on or after the given timestamp.

                                                                                        func (*ProcessesListCall) UserProcessFilterStatuses

                                                                                        func (c *ProcessesListCall) UserProcessFilterStatuses(userProcessFilterStatuses ...string) *ProcessesListCall

                                                                                          UserProcessFilterStatuses sets the optional parameter "userProcessFilter.statuses": Optional field used to limit returned processes to those having one of the specified process statuses.

                                                                                          Possible values:

                                                                                          "PROCESS_STATUS_UNSPECIFIED"
                                                                                          "RUNNING"
                                                                                          "PAUSED"
                                                                                          "COMPLETED"
                                                                                          "CANCELED"
                                                                                          "FAILED"
                                                                                          "TIMED_OUT"
                                                                                          "UNKNOWN"
                                                                                          "DELAYED"
                                                                                          

                                                                                          func (*ProcessesListCall) UserProcessFilterTypes

                                                                                          func (c *ProcessesListCall) UserProcessFilterTypes(userProcessFilterTypes ...string) *ProcessesListCall

                                                                                            UserProcessFilterTypes sets the optional parameter "userProcessFilter.types": Optional field used to limit returned processes to those having one of the specified process types.

                                                                                            Possible values:

                                                                                            "PROCESS_TYPE_UNSPECIFIED"
                                                                                            "ADD_ON"
                                                                                            "EXECUTION_API"
                                                                                            "TIME_DRIVEN"
                                                                                            "TRIGGER"
                                                                                            "WEBAPP"
                                                                                            "EDITOR"
                                                                                            "SIMPLE_TRIGGER"
                                                                                            "MENU"
                                                                                            "BATCH_TASK"
                                                                                            

                                                                                            func (*ProcessesListCall) UserProcessFilterUserAccessLevels

                                                                                            func (c *ProcessesListCall) UserProcessFilterUserAccessLevels(userProcessFilterUserAccessLevels ...string) *ProcessesListCall

                                                                                              UserProcessFilterUserAccessLevels sets the optional parameter "userProcessFilter.userAccessLevels": Optional field used to limit returned processes to those having one of the specified user access levels.

                                                                                              Possible values:

                                                                                              "USER_ACCESS_LEVEL_UNSPECIFIED"
                                                                                              "NONE"
                                                                                              "READ"
                                                                                              "WRITE"
                                                                                              "OWNER"
                                                                                              

                                                                                              type ProcessesListScriptProcessesCall

                                                                                              type ProcessesListScriptProcessesCall struct {
                                                                                              	// contains filtered or unexported fields
                                                                                              }

                                                                                              func (*ProcessesListScriptProcessesCall) Context

                                                                                                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 (*ProcessesListScriptProcessesCall) Do

                                                                                                  Do executes the "script.processes.listScriptProcesses" call. Exactly one of *ListScriptProcessesResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *ListScriptProcessesResponse.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 (*ProcessesListScriptProcessesCall) Fields

                                                                                                    Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                    func (*ProcessesListScriptProcessesCall) Header

                                                                                                      Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                      func (*ProcessesListScriptProcessesCall) IfNoneMatch

                                                                                                        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 (*ProcessesListScriptProcessesCall) PageSize

                                                                                                          PageSize sets the optional parameter "pageSize": The maximum number of returned processes per page of results. Defaults to 50.

                                                                                                          func (*ProcessesListScriptProcessesCall) PageToken

                                                                                                            PageToken sets the optional parameter "pageToken": The token for continuing a previous list request on the next page. This should be set to the value of `nextPageToken` from a previous response.

                                                                                                            func (*ProcessesListScriptProcessesCall) Pages

                                                                                                              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 (*ProcessesListScriptProcessesCall) ScriptId

                                                                                                                ScriptId sets the optional parameter "scriptId": The script ID of the project whose processes are listed.

                                                                                                                func (*ProcessesListScriptProcessesCall) ScriptProcessFilterDeploymentId

                                                                                                                func (c *ProcessesListScriptProcessesCall) ScriptProcessFilterDeploymentId(scriptProcessFilterDeploymentId string) *ProcessesListScriptProcessesCall

                                                                                                                  ScriptProcessFilterDeploymentId sets the optional parameter "scriptProcessFilter.deploymentId": Optional field used to limit returned processes to those originating from projects with a specific deployment ID.

                                                                                                                  func (*ProcessesListScriptProcessesCall) ScriptProcessFilterEndTime

                                                                                                                  func (c *ProcessesListScriptProcessesCall) ScriptProcessFilterEndTime(scriptProcessFilterEndTime string) *ProcessesListScriptProcessesCall

                                                                                                                    ScriptProcessFilterEndTime sets the optional parameter "scriptProcessFilter.endTime": Optional field used to limit returned processes to those that completed on or before the given timestamp.

                                                                                                                    func (*ProcessesListScriptProcessesCall) ScriptProcessFilterFunctionName

                                                                                                                    func (c *ProcessesListScriptProcessesCall) ScriptProcessFilterFunctionName(scriptProcessFilterFunctionName string) *ProcessesListScriptProcessesCall

                                                                                                                      ScriptProcessFilterFunctionName sets the optional parameter "scriptProcessFilter.functionName": Optional field used to limit returned processes to those originating from a script function with the given function name.

                                                                                                                      func (*ProcessesListScriptProcessesCall) ScriptProcessFilterStartTime

                                                                                                                      func (c *ProcessesListScriptProcessesCall) ScriptProcessFilterStartTime(scriptProcessFilterStartTime string) *ProcessesListScriptProcessesCall

                                                                                                                        ScriptProcessFilterStartTime sets the optional parameter "scriptProcessFilter.startTime": Optional field used to limit returned processes to those that were started on or after the given timestamp.

                                                                                                                        func (*ProcessesListScriptProcessesCall) ScriptProcessFilterStatuses

                                                                                                                        func (c *ProcessesListScriptProcessesCall) ScriptProcessFilterStatuses(scriptProcessFilterStatuses ...string) *ProcessesListScriptProcessesCall

                                                                                                                          ScriptProcessFilterStatuses sets the optional parameter "scriptProcessFilter.statuses": Optional field used to limit returned processes to those having one of the specified process statuses.

                                                                                                                          Possible values:

                                                                                                                          "PROCESS_STATUS_UNSPECIFIED"
                                                                                                                          "RUNNING"
                                                                                                                          "PAUSED"
                                                                                                                          "COMPLETED"
                                                                                                                          "CANCELED"
                                                                                                                          "FAILED"
                                                                                                                          "TIMED_OUT"
                                                                                                                          "UNKNOWN"
                                                                                                                          "DELAYED"
                                                                                                                          

                                                                                                                          func (*ProcessesListScriptProcessesCall) ScriptProcessFilterTypes

                                                                                                                          func (c *ProcessesListScriptProcessesCall) ScriptProcessFilterTypes(scriptProcessFilterTypes ...string) *ProcessesListScriptProcessesCall

                                                                                                                            ScriptProcessFilterTypes sets the optional parameter "scriptProcessFilter.types": Optional field used to limit returned processes to those having one of the specified process types.

                                                                                                                            Possible values:

                                                                                                                            "PROCESS_TYPE_UNSPECIFIED"
                                                                                                                            "ADD_ON"
                                                                                                                            "EXECUTION_API"
                                                                                                                            "TIME_DRIVEN"
                                                                                                                            "TRIGGER"
                                                                                                                            "WEBAPP"
                                                                                                                            "EDITOR"
                                                                                                                            "SIMPLE_TRIGGER"
                                                                                                                            "MENU"
                                                                                                                            "BATCH_TASK"
                                                                                                                            

                                                                                                                            func (*ProcessesListScriptProcessesCall) ScriptProcessFilterUserAccessLevels

                                                                                                                            func (c *ProcessesListScriptProcessesCall) ScriptProcessFilterUserAccessLevels(scriptProcessFilterUserAccessLevels ...string) *ProcessesListScriptProcessesCall

                                                                                                                              ScriptProcessFilterUserAccessLevels sets the optional parameter "scriptProcessFilter.userAccessLevels": Optional field used to limit returned processes to those having one of the specified user access levels.

                                                                                                                              Possible values:

                                                                                                                              "USER_ACCESS_LEVEL_UNSPECIFIED"
                                                                                                                              "NONE"
                                                                                                                              "READ"
                                                                                                                              "WRITE"
                                                                                                                              "OWNER"
                                                                                                                              

                                                                                                                              type ProcessesService

                                                                                                                              type ProcessesService struct {
                                                                                                                              	// contains filtered or unexported fields
                                                                                                                              }

                                                                                                                              func NewProcessesService

                                                                                                                              func NewProcessesService(s *Service) *ProcessesService

                                                                                                                              func (*ProcessesService) List

                                                                                                                                List: List information about processes made by or on behalf of a user, such as process type and current status.

                                                                                                                                func (*ProcessesService) ListScriptProcesses

                                                                                                                                func (r *ProcessesService) ListScriptProcesses() *ProcessesListScriptProcessesCall

                                                                                                                                  ListScriptProcesses: List information about a script's executed processes, such as process type and current status.

                                                                                                                                  type Project

                                                                                                                                  type Project struct {
                                                                                                                                  	// CreateTime: When the script was created.
                                                                                                                                  	CreateTime string `json:"createTime,omitempty"`
                                                                                                                                  
                                                                                                                                  	// Creator: User who originally created the script.
                                                                                                                                  	Creator *GoogleAppsScriptTypeUser `json:"creator,omitempty"`
                                                                                                                                  
                                                                                                                                  	// LastModifyUser: User who last modified the script.
                                                                                                                                  	LastModifyUser *GoogleAppsScriptTypeUser `json:"lastModifyUser,omitempty"`
                                                                                                                                  
                                                                                                                                  	// ParentId: The parent's Drive ID that the script will be attached to.
                                                                                                                                  	// This is usually
                                                                                                                                  	// the ID of a Google Document or Google Sheet. This filed is optional,
                                                                                                                                  	// and
                                                                                                                                  	// if not set, a stand-alone script will be created.
                                                                                                                                  	ParentId string `json:"parentId,omitempty"`
                                                                                                                                  
                                                                                                                                  	// ScriptId: The script project's Drive ID.
                                                                                                                                  	ScriptId string `json:"scriptId,omitempty"`
                                                                                                                                  
                                                                                                                                  	// Title: The title for the project.
                                                                                                                                  	Title string `json:"title,omitempty"`
                                                                                                                                  
                                                                                                                                  	// UpdateTime: When the script was last updated.
                                                                                                                                  	UpdateTime string `json:"updateTime,omitempty"`
                                                                                                                                  
                                                                                                                                  	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                  	// server.
                                                                                                                                  	googleapi.ServerResponse `json:"-"`
                                                                                                                                  
                                                                                                                                  	// ForceSendFields is a list of field names (e.g. "CreateTime") to
                                                                                                                                  	// unconditionally include in API requests. By default, fields with
                                                                                                                                  	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                  	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                  	// server regardless of whether the field is empty or not. This may be
                                                                                                                                  	// used to include empty fields in Patch requests.
                                                                                                                                  	ForceSendFields []string `json:"-"`
                                                                                                                                  
                                                                                                                                  	// NullFields is a list of field names (e.g. "CreateTime") 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:"-"`
                                                                                                                                  }

                                                                                                                                    Project: The script project resource.

                                                                                                                                    func (*Project) MarshalJSON

                                                                                                                                    func (s *Project) MarshalJSON() ([]byte, error)

                                                                                                                                    type ProjectsCreateCall

                                                                                                                                    type ProjectsCreateCall struct {
                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                    }

                                                                                                                                    func (*ProjectsCreateCall) Context

                                                                                                                                      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 (*ProjectsCreateCall) Do

                                                                                                                                        Do executes the "script.projects.create" call. Exactly one of *Project or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Project.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 (*ProjectsCreateCall) Fields

                                                                                                                                          Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                          func (*ProjectsCreateCall) Header

                                                                                                                                          func (c *ProjectsCreateCall) Header() http.Header

                                                                                                                                            Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                            type ProjectsDeploymentsCreateCall

                                                                                                                                            type ProjectsDeploymentsCreateCall struct {
                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                            }

                                                                                                                                            func (*ProjectsDeploymentsCreateCall) Context

                                                                                                                                              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 (*ProjectsDeploymentsCreateCall) Do

                                                                                                                                                Do executes the "script.projects.deployments.create" call. Exactly one of *Deployment or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Deployment.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 (*ProjectsDeploymentsCreateCall) Fields

                                                                                                                                                  Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                  func (*ProjectsDeploymentsCreateCall) Header

                                                                                                                                                    Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                    type ProjectsDeploymentsDeleteCall

                                                                                                                                                    type ProjectsDeploymentsDeleteCall struct {
                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                    }

                                                                                                                                                    func (*ProjectsDeploymentsDeleteCall) Context

                                                                                                                                                      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 (*ProjectsDeploymentsDeleteCall) Do

                                                                                                                                                        Do executes the "script.projects.deployments.delete" call. Exactly one of *Empty or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Empty.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 (*ProjectsDeploymentsDeleteCall) Fields

                                                                                                                                                          Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                          func (*ProjectsDeploymentsDeleteCall) Header

                                                                                                                                                            Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                            type ProjectsDeploymentsGetCall

                                                                                                                                                            type ProjectsDeploymentsGetCall struct {
                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                            }

                                                                                                                                                            func (*ProjectsDeploymentsGetCall) Context

                                                                                                                                                              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 (*ProjectsDeploymentsGetCall) Do

                                                                                                                                                                Do executes the "script.projects.deployments.get" call. Exactly one of *Deployment or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Deployment.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 (*ProjectsDeploymentsGetCall) Fields

                                                                                                                                                                  Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                  func (*ProjectsDeploymentsGetCall) Header

                                                                                                                                                                    Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                    func (*ProjectsDeploymentsGetCall) IfNoneMatch

                                                                                                                                                                      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.

                                                                                                                                                                      type ProjectsDeploymentsListCall

                                                                                                                                                                      type ProjectsDeploymentsListCall struct {
                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                      }

                                                                                                                                                                      func (*ProjectsDeploymentsListCall) Context

                                                                                                                                                                        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 (*ProjectsDeploymentsListCall) Do

                                                                                                                                                                          Do executes the "script.projects.deployments.list" call. Exactly one of *ListDeploymentsResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *ListDeploymentsResponse.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 (*ProjectsDeploymentsListCall) Fields

                                                                                                                                                                            Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                            func (*ProjectsDeploymentsListCall) Header

                                                                                                                                                                              Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                              func (*ProjectsDeploymentsListCall) IfNoneMatch

                                                                                                                                                                                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 (*ProjectsDeploymentsListCall) PageSize

                                                                                                                                                                                  PageSize sets the optional parameter "pageSize": The maximum number of deployments on each returned page. Defaults to 50.

                                                                                                                                                                                  func (*ProjectsDeploymentsListCall) PageToken

                                                                                                                                                                                    PageToken sets the optional parameter "pageToken": The token for continuing a previous list request on the next page. This should be set to the value of `nextPageToken` from a previous response.

                                                                                                                                                                                    func (*ProjectsDeploymentsListCall) Pages

                                                                                                                                                                                      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.

                                                                                                                                                                                      type ProjectsDeploymentsService

                                                                                                                                                                                      type ProjectsDeploymentsService struct {
                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                      }

                                                                                                                                                                                      func NewProjectsDeploymentsService

                                                                                                                                                                                      func NewProjectsDeploymentsService(s *Service) *ProjectsDeploymentsService

                                                                                                                                                                                      func (*ProjectsDeploymentsService) Create

                                                                                                                                                                                      func (r *ProjectsDeploymentsService) Create(scriptId string, deploymentconfig *DeploymentConfig) *ProjectsDeploymentsCreateCall

                                                                                                                                                                                        Create: Creates a deployment of an Apps Script project.

                                                                                                                                                                                        func (*ProjectsDeploymentsService) Delete

                                                                                                                                                                                        func (r *ProjectsDeploymentsService) Delete(scriptId string, deploymentId string) *ProjectsDeploymentsDeleteCall

                                                                                                                                                                                          Delete: Deletes a deployment of an Apps Script project.

                                                                                                                                                                                          func (*ProjectsDeploymentsService) Get

                                                                                                                                                                                          func (r *ProjectsDeploymentsService) Get(scriptId string, deploymentId string) *ProjectsDeploymentsGetCall

                                                                                                                                                                                            Get: Gets a deployment of an Apps Script project.

                                                                                                                                                                                            func (*ProjectsDeploymentsService) List

                                                                                                                                                                                              List: Lists the deployments of an Apps Script project.

                                                                                                                                                                                              func (*ProjectsDeploymentsService) Update

                                                                                                                                                                                              func (r *ProjectsDeploymentsService) Update(scriptId string, deploymentId string, updatedeploymentrequest *UpdateDeploymentRequest) *ProjectsDeploymentsUpdateCall

                                                                                                                                                                                                Update: Updates a deployment of an Apps Script project.

                                                                                                                                                                                                type ProjectsDeploymentsUpdateCall

                                                                                                                                                                                                type ProjectsDeploymentsUpdateCall struct {
                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                }

                                                                                                                                                                                                func (*ProjectsDeploymentsUpdateCall) Context

                                                                                                                                                                                                  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 (*ProjectsDeploymentsUpdateCall) Do

                                                                                                                                                                                                    Do executes the "script.projects.deployments.update" call. Exactly one of *Deployment or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Deployment.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 (*ProjectsDeploymentsUpdateCall) Fields

                                                                                                                                                                                                      Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                      func (*ProjectsDeploymentsUpdateCall) Header

                                                                                                                                                                                                        Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                        type ProjectsGetCall

                                                                                                                                                                                                        type ProjectsGetCall struct {
                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                        }

                                                                                                                                                                                                        func (*ProjectsGetCall) Context

                                                                                                                                                                                                          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 (*ProjectsGetCall) Do

                                                                                                                                                                                                          func (c *ProjectsGetCall) Do(opts ...googleapi.CallOption) (*Project, error)

                                                                                                                                                                                                            Do executes the "script.projects.get" call. Exactly one of *Project or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Project.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 (*ProjectsGetCall) Fields

                                                                                                                                                                                                              Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                              func (*ProjectsGetCall) Header

                                                                                                                                                                                                              func (c *ProjectsGetCall) Header() http.Header

                                                                                                                                                                                                                Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                func (*ProjectsGetCall) IfNoneMatch

                                                                                                                                                                                                                func (c *ProjectsGetCall) IfNoneMatch(entityTag string) *ProjectsGetCall

                                                                                                                                                                                                                  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.

                                                                                                                                                                                                                  type ProjectsGetContentCall

                                                                                                                                                                                                                  type ProjectsGetContentCall struct {
                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                  }

                                                                                                                                                                                                                  func (*ProjectsGetContentCall) Context

                                                                                                                                                                                                                    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 (*ProjectsGetContentCall) Do

                                                                                                                                                                                                                      Do executes the "script.projects.getContent" call. Exactly one of *Content or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Content.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 (*ProjectsGetContentCall) Fields

                                                                                                                                                                                                                        Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                        func (*ProjectsGetContentCall) Header

                                                                                                                                                                                                                        func (c *ProjectsGetContentCall) Header() http.Header

                                                                                                                                                                                                                          Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                          func (*ProjectsGetContentCall) IfNoneMatch

                                                                                                                                                                                                                          func (c *ProjectsGetContentCall) IfNoneMatch(entityTag string) *ProjectsGetContentCall

                                                                                                                                                                                                                            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 (*ProjectsGetContentCall) VersionNumber

                                                                                                                                                                                                                            func (c *ProjectsGetContentCall) VersionNumber(versionNumber int64) *ProjectsGetContentCall

                                                                                                                                                                                                                              VersionNumber sets the optional parameter "versionNumber": The version number of the project to retrieve. If not provided, the project's HEAD version is returned.

                                                                                                                                                                                                                              type ProjectsGetMetricsCall

                                                                                                                                                                                                                              type ProjectsGetMetricsCall struct {
                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                              }

                                                                                                                                                                                                                              func (*ProjectsGetMetricsCall) Context

                                                                                                                                                                                                                                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 (*ProjectsGetMetricsCall) Do

                                                                                                                                                                                                                                  Do executes the "script.projects.getMetrics" call. Exactly one of *Metrics or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Metrics.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 (*ProjectsGetMetricsCall) Fields

                                                                                                                                                                                                                                    Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                                    func (*ProjectsGetMetricsCall) Header

                                                                                                                                                                                                                                    func (c *ProjectsGetMetricsCall) Header() http.Header

                                                                                                                                                                                                                                      Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                      func (*ProjectsGetMetricsCall) IfNoneMatch

                                                                                                                                                                                                                                      func (c *ProjectsGetMetricsCall) IfNoneMatch(entityTag string) *ProjectsGetMetricsCall

                                                                                                                                                                                                                                        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 (*ProjectsGetMetricsCall) MetricsFilterDeploymentId

                                                                                                                                                                                                                                        func (c *ProjectsGetMetricsCall) MetricsFilterDeploymentId(metricsFilterDeploymentId string) *ProjectsGetMetricsCall

                                                                                                                                                                                                                                          MetricsFilterDeploymentId sets the optional parameter "metricsFilter.deploymentId": Optional field indicating a specific deployment to retrieve metrics from.

                                                                                                                                                                                                                                          func (*ProjectsGetMetricsCall) MetricsGranularity

                                                                                                                                                                                                                                          func (c *ProjectsGetMetricsCall) MetricsGranularity(metricsGranularity string) *ProjectsGetMetricsCall

                                                                                                                                                                                                                                            MetricsGranularity sets the optional parameter "metricsGranularity": Required field indicating what granularity of metrics are returned.

                                                                                                                                                                                                                                            Possible values:

                                                                                                                                                                                                                                            "UNSPECIFIED_GRANULARITY"
                                                                                                                                                                                                                                            "WEEKLY"
                                                                                                                                                                                                                                            "DAILY"
                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                            type ProjectsService

                                                                                                                                                                                                                                            type ProjectsService struct {
                                                                                                                                                                                                                                            	Deployments *ProjectsDeploymentsService
                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                            	Versions *ProjectsVersionsService
                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                            func NewProjectsService

                                                                                                                                                                                                                                            func NewProjectsService(s *Service) *ProjectsService

                                                                                                                                                                                                                                            func (*ProjectsService) Create

                                                                                                                                                                                                                                            func (r *ProjectsService) Create(createprojectrequest *CreateProjectRequest) *ProjectsCreateCall

                                                                                                                                                                                                                                              Create: Creates a new, empty script project with no script files and a base manifest file.

                                                                                                                                                                                                                                              func (*ProjectsService) Get

                                                                                                                                                                                                                                              func (r *ProjectsService) Get(scriptId string) *ProjectsGetCall

                                                                                                                                                                                                                                                Get: Gets a script project's metadata.

                                                                                                                                                                                                                                                func (*ProjectsService) GetContent

                                                                                                                                                                                                                                                func (r *ProjectsService) GetContent(scriptId string) *ProjectsGetContentCall

                                                                                                                                                                                                                                                  GetContent: Gets the content of the script project, including the code source and metadata for each script file.

                                                                                                                                                                                                                                                  func (*ProjectsService) GetMetrics

                                                                                                                                                                                                                                                  func (r *ProjectsService) GetMetrics(scriptId string) *ProjectsGetMetricsCall

                                                                                                                                                                                                                                                    GetMetrics: Get metrics data for scripts, such as number of executions and active users.

                                                                                                                                                                                                                                                    func (*ProjectsService) UpdateContent

                                                                                                                                                                                                                                                    func (r *ProjectsService) UpdateContent(scriptId string, content *Content) *ProjectsUpdateContentCall

                                                                                                                                                                                                                                                      UpdateContent: Updates the content of the specified script project. This content is stored as the HEAD version, and is used when the script is executed as a trigger, in the script editor, in add-on preview mode, or as a web app or Apps Script API in development mode. This clears all the existing files in the project.

                                                                                                                                                                                                                                                      type ProjectsUpdateContentCall

                                                                                                                                                                                                                                                      type ProjectsUpdateContentCall struct {
                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                      func (*ProjectsUpdateContentCall) Context

                                                                                                                                                                                                                                                        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 (*ProjectsUpdateContentCall) Do

                                                                                                                                                                                                                                                          Do executes the "script.projects.updateContent" call. Exactly one of *Content or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Content.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 (*ProjectsUpdateContentCall) Fields

                                                                                                                                                                                                                                                            Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                                                            func (*ProjectsUpdateContentCall) Header

                                                                                                                                                                                                                                                              Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                                              type ProjectsVersionsCreateCall

                                                                                                                                                                                                                                                              type ProjectsVersionsCreateCall struct {
                                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                              func (*ProjectsVersionsCreateCall) Context

                                                                                                                                                                                                                                                                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 (*ProjectsVersionsCreateCall) Do

                                                                                                                                                                                                                                                                  Do executes the "script.projects.versions.create" call. Exactly one of *Version or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Version.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 (*ProjectsVersionsCreateCall) Fields

                                                                                                                                                                                                                                                                    Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                                                                    func (*ProjectsVersionsCreateCall) Header

                                                                                                                                                                                                                                                                      Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                                                      type ProjectsVersionsGetCall

                                                                                                                                                                                                                                                                      type ProjectsVersionsGetCall struct {
                                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                      func (*ProjectsVersionsGetCall) Context

                                                                                                                                                                                                                                                                        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 (*ProjectsVersionsGetCall) Do

                                                                                                                                                                                                                                                                          Do executes the "script.projects.versions.get" call. Exactly one of *Version or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Version.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 (*ProjectsVersionsGetCall) Fields

                                                                                                                                                                                                                                                                            Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                                                                            func (*ProjectsVersionsGetCall) Header

                                                                                                                                                                                                                                                                            func (c *ProjectsVersionsGetCall) Header() http.Header

                                                                                                                                                                                                                                                                              Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                                                              func (*ProjectsVersionsGetCall) IfNoneMatch

                                                                                                                                                                                                                                                                              func (c *ProjectsVersionsGetCall) IfNoneMatch(entityTag string) *ProjectsVersionsGetCall

                                                                                                                                                                                                                                                                                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.

                                                                                                                                                                                                                                                                                type ProjectsVersionsListCall

                                                                                                                                                                                                                                                                                type ProjectsVersionsListCall struct {
                                                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                func (*ProjectsVersionsListCall) Context

                                                                                                                                                                                                                                                                                  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 (*ProjectsVersionsListCall) Do

                                                                                                                                                                                                                                                                                    Do executes the "script.projects.versions.list" call. Exactly one of *ListVersionsResponse or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *ListVersionsResponse.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 (*ProjectsVersionsListCall) Fields

                                                                                                                                                                                                                                                                                      Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                                                                                      func (*ProjectsVersionsListCall) Header

                                                                                                                                                                                                                                                                                      func (c *ProjectsVersionsListCall) Header() http.Header

                                                                                                                                                                                                                                                                                        Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                                                                        func (*ProjectsVersionsListCall) IfNoneMatch

                                                                                                                                                                                                                                                                                        func (c *ProjectsVersionsListCall) IfNoneMatch(entityTag string) *ProjectsVersionsListCall

                                                                                                                                                                                                                                                                                          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 (*ProjectsVersionsListCall) PageSize

                                                                                                                                                                                                                                                                                            PageSize sets the optional parameter "pageSize": The maximum number of versions on each returned page. Defaults to 50.

                                                                                                                                                                                                                                                                                            func (*ProjectsVersionsListCall) PageToken

                                                                                                                                                                                                                                                                                            func (c *ProjectsVersionsListCall) PageToken(pageToken string) *ProjectsVersionsListCall

                                                                                                                                                                                                                                                                                              PageToken sets the optional parameter "pageToken": The token for continuing a previous list request on the next page. This should be set to the value of `nextPageToken` from a previous response.

                                                                                                                                                                                                                                                                                              func (*ProjectsVersionsListCall) Pages

                                                                                                                                                                                                                                                                                                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.

                                                                                                                                                                                                                                                                                                type ProjectsVersionsService

                                                                                                                                                                                                                                                                                                type ProjectsVersionsService struct {
                                                                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                func NewProjectsVersionsService

                                                                                                                                                                                                                                                                                                func NewProjectsVersionsService(s *Service) *ProjectsVersionsService

                                                                                                                                                                                                                                                                                                func (*ProjectsVersionsService) Create

                                                                                                                                                                                                                                                                                                func (r *ProjectsVersionsService) Create(scriptId string, version *Version) *ProjectsVersionsCreateCall

                                                                                                                                                                                                                                                                                                  Create: Creates a new immutable version using the current code, with a unique version number.

                                                                                                                                                                                                                                                                                                  func (*ProjectsVersionsService) Get

                                                                                                                                                                                                                                                                                                  func (r *ProjectsVersionsService) Get(scriptId string, versionNumber int64) *ProjectsVersionsGetCall

                                                                                                                                                                                                                                                                                                    Get: Gets a version of a script project.

                                                                                                                                                                                                                                                                                                    func (*ProjectsVersionsService) List

                                                                                                                                                                                                                                                                                                      List: List the versions of a script project.

                                                                                                                                                                                                                                                                                                      type ScriptExecutionResult

                                                                                                                                                                                                                                                                                                      type ScriptExecutionResult struct {
                                                                                                                                                                                                                                                                                                      	// ReturnValue: The returned value of the execution.
                                                                                                                                                                                                                                                                                                      	// TODO (johnlattin): Add HtmlResponse
                                                                                                                                                                                                                                                                                                      	// TODO (johnlattin): Add ExceptionResponse
                                                                                                                                                                                                                                                                                                      	// TODO (johlnattin): Add TextResponse
                                                                                                                                                                                                                                                                                                      	ReturnValue *Value `json:"returnValue,omitempty"`
                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                      	// ForceSendFields is a list of field names (e.g. "ReturnValue") to
                                                                                                                                                                                                                                                                                                      	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                                                                                                                      	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                                                                                                                      	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                                                                                                                      	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                                                                                                                      	// used to include empty fields in Patch requests.
                                                                                                                                                                                                                                                                                                      	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                                      	// NullFields is a list of field names (e.g. "ReturnValue") 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:"-"`
                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                        ScriptExecutionResult: The result of an execution Based on ScriptExecutionResult at: google3/apps/maestro/api/frontend_execution_common.proto?q=message %5c%20ScriptExecutionResult

                                                                                                                                                                                                                                                                                                        func (*ScriptExecutionResult) MarshalJSON

                                                                                                                                                                                                                                                                                                        func (s *ScriptExecutionResult) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                                                                                                                        type ScriptStackTraceElement

                                                                                                                                                                                                                                                                                                        type ScriptStackTraceElement struct {
                                                                                                                                                                                                                                                                                                        	// Function: The name of the function that failed.
                                                                                                                                                                                                                                                                                                        	Function string `json:"function,omitempty"`
                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                        	// LineNumber: The line number where the script failed.
                                                                                                                                                                                                                                                                                                        	LineNumber int64 `json:"lineNumber,omitempty"`
                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                        	// ForceSendFields is a list of field names (e.g. "Function") to
                                                                                                                                                                                                                                                                                                        	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                                                                                                                        	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                                                                                                                        	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                                                                                                                        	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                                                                                                                        	// used to include empty fields in Patch requests.
                                                                                                                                                                                                                                                                                                        	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                        	// NullFields is a list of field names (e.g. "Function") 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:"-"`
                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                          ScriptStackTraceElement: A stack trace through the script that shows where the execution failed.

                                                                                                                                                                                                                                                                                                          func (*ScriptStackTraceElement) MarshalJSON

                                                                                                                                                                                                                                                                                                          func (s *ScriptStackTraceElement) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                                                                                                                          type ScriptsRunCall

                                                                                                                                                                                                                                                                                                          type ScriptsRunCall struct {
                                                                                                                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                          func (*ScriptsRunCall) Context

                                                                                                                                                                                                                                                                                                          func (c *ScriptsRunCall) Context(ctx context.Context) *ScriptsRunCall

                                                                                                                                                                                                                                                                                                            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 (*ScriptsRunCall) Do

                                                                                                                                                                                                                                                                                                            func (c *ScriptsRunCall) Do(opts ...googleapi.CallOption) (*Operation, error)

                                                                                                                                                                                                                                                                                                              Do executes the "script.scripts.run" call. Exactly one of *Operation or error will be non-nil. Any non-2xx status code is an error. Response headers are in either *Operation.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 (*ScriptsRunCall) Fields

                                                                                                                                                                                                                                                                                                              func (c *ScriptsRunCall) Fields(s ...googleapi.Field) *ScriptsRunCall

                                                                                                                                                                                                                                                                                                                Fields allows partial responses to be retrieved. See https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more information.

                                                                                                                                                                                                                                                                                                                func (*ScriptsRunCall) Header

                                                                                                                                                                                                                                                                                                                func (c *ScriptsRunCall) Header() http.Header

                                                                                                                                                                                                                                                                                                                  Header returns an http.Header that can be modified by the caller to add HTTP headers to the request.

                                                                                                                                                                                                                                                                                                                  type ScriptsService

                                                                                                                                                                                                                                                                                                                  type ScriptsService struct {
                                                                                                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                  func NewScriptsService

                                                                                                                                                                                                                                                                                                                  func NewScriptsService(s *Service) *ScriptsService

                                                                                                                                                                                                                                                                                                                  func (*ScriptsService) Run

                                                                                                                                                                                                                                                                                                                  func (r *ScriptsService) Run(scriptId string, executionrequest *ExecutionRequest) *ScriptsRunCall

                                                                                                                                                                                                                                                                                                                    Run: Runs a function in an Apps Script project. The script project must be deployed for use with the Apps Script API and the calling application must share the same Cloud Platform project.

                                                                                                                                                                                                                                                                                                                    This method requires authorization with an OAuth 2.0 token that includes at least one of the scopes listed in the [Authorization](#authorization-scopes) section; script projects that do not require authorization cannot be executed through this API. To find the correct scopes to include in the authentication token, open the project in the script editor, then select **File > Project properties** and click the **Scopes** tab.

                                                                                                                                                                                                                                                                                                                    The error `403, PERMISSION_DENIED: The caller does not have permission` indicates that the Cloud Platform project used to authorize the request is not the same as the one used by the script.

                                                                                                                                                                                                                                                                                                                    type Service

                                                                                                                                                                                                                                                                                                                    type Service struct {
                                                                                                                                                                                                                                                                                                                    	BasePath  string // API endpoint base URL
                                                                                                                                                                                                                                                                                                                    	UserAgent string // optional additional User-Agent fragment
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    	Processes *ProcessesService
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    	Projects *ProjectsService
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    	Scripts *ScriptsService
                                                                                                                                                                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                    func New

                                                                                                                                                                                                                                                                                                                    func New(client *http.Client) (*Service, error)

                                                                                                                                                                                                                                                                                                                      New creates a new Service. It uses the provided http.Client for requests.

                                                                                                                                                                                                                                                                                                                      Deprecated: please use NewService instead. To provide a custom HTTP client, use option.WithHTTPClient. If you are using google.golang.org/api/googleapis/transport.APIKey, use option.WithAPIKey with NewService instead.

                                                                                                                                                                                                                                                                                                                      func NewService

                                                                                                                                                                                                                                                                                                                      func NewService(ctx context.Context, opts ...option.ClientOption) (*Service, error)

                                                                                                                                                                                                                                                                                                                        NewService creates a new Service.

                                                                                                                                                                                                                                                                                                                        type Status

                                                                                                                                                                                                                                                                                                                        type Status struct {
                                                                                                                                                                                                                                                                                                                        	// Code: The status code. For this API, this value either: <ul> <li> 10,
                                                                                                                                                                                                                                                                                                                        	// indicating a `SCRIPT_TIMEOUT` error,</li> <li> 3, indicating an
                                                                                                                                                                                                                                                                                                                        	// `INVALID_ARGUMENT` error, or</li> <li> 1, indicating a `CANCELLED`
                                                                                                                                                                                                                                                                                                                        	// execution.</li> </ul>
                                                                                                                                                                                                                                                                                                                        	Code int64 `json:"code,omitempty"`
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// Details: An array that contains a single ExecutionError object that
                                                                                                                                                                                                                                                                                                                        	// provides information about the nature of the error.
                                                                                                                                                                                                                                                                                                                        	Details []googleapi.RawMessage `json:"details,omitempty"`
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// Message: A developer-facing error message, which is in English. Any
                                                                                                                                                                                                                                                                                                                        	// user-facing error message is localized and sent in the details field,
                                                                                                                                                                                                                                                                                                                        	// or localized by the client.
                                                                                                                                                                                                                                                                                                                        	Message string `json:"message,omitempty"`
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// ForceSendFields is a list of field names (e.g. "Code") to
                                                                                                                                                                                                                                                                                                                        	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                                                                                                                                        	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                                                                                                                                        	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                                                                                                                                        	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                                                                                                                                        	// used to include empty fields in Patch requests.
                                                                                                                                                                                                                                                                                                                        	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                        	// NullFields is a list of field names (e.g. "Code") 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:"-"`
                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                          Status: If a `run` call succeeds but the script function (or Apps Script itself) throws an exception, the response body's error field contains this `Status` object.

                                                                                                                                                                                                                                                                                                                          func (*Status) MarshalJSON

                                                                                                                                                                                                                                                                                                                          func (s *Status) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                                                                                                                                          type Struct

                                                                                                                                                                                                                                                                                                                          type Struct struct {
                                                                                                                                                                                                                                                                                                                          	// Fields: Unordered map of dynamically typed values.
                                                                                                                                                                                                                                                                                                                          	Fields map[string]Value `json:"fields,omitempty"`
                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                          	// ForceSendFields is a list of field names (e.g. "Fields") to
                                                                                                                                                                                                                                                                                                                          	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                                                                                                                                          	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                                                                                                                                          	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                                                                                                                                          	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                                                                                                                                          	// used to include empty fields in Patch requests.
                                                                                                                                                                                                                                                                                                                          	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                          	// NullFields is a list of field names (e.g. "Fields") 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:"-"`
                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                            Struct: `Struct` represents a structured data value, consisting of fields which map to dynamically typed values. Based on Struct at: google3/apps/maestro/api/struct.proto?q=message%5c%20Struct

                                                                                                                                                                                                                                                                                                                            func (*Struct) MarshalJSON

                                                                                                                                                                                                                                                                                                                            func (s *Struct) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                                                                                                                                            type UpdateDeploymentRequest

                                                                                                                                                                                                                                                                                                                            type UpdateDeploymentRequest struct {
                                                                                                                                                                                                                                                                                                                            	// DeploymentConfig: The deployment configuration.
                                                                                                                                                                                                                                                                                                                            	DeploymentConfig *DeploymentConfig `json:"deploymentConfig,omitempty"`
                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                            	// ForceSendFields is a list of field names (e.g. "DeploymentConfig") to
                                                                                                                                                                                                                                                                                                                            	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                                                                                                                                            	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                                                                                                                                            	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                                                                                                                                            	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                                                                                                                                            	// used to include empty fields in Patch requests.
                                                                                                                                                                                                                                                                                                                            	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                            	// NullFields is a list of field names (e.g. "DeploymentConfig") 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:"-"`
                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                              UpdateDeploymentRequest: Request with deployment information to update an existing deployment.

                                                                                                                                                                                                                                                                                                                              func (*UpdateDeploymentRequest) MarshalJSON

                                                                                                                                                                                                                                                                                                                              func (s *UpdateDeploymentRequest) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                                                                                                                                              type Value

                                                                                                                                                                                                                                                                                                                              type Value struct {
                                                                                                                                                                                                                                                                                                                              	// BoolValue: Represents a boolean value.
                                                                                                                                                                                                                                                                                                                              	BoolValue bool `json:"boolValue,omitempty"`
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// BytesValue: Represents raw byte values.
                                                                                                                                                                                                                                                                                                                              	BytesValue string `json:"bytesValue,omitempty"`
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// DateValue: Represents a date in ms since the epoch.
                                                                                                                                                                                                                                                                                                                              	DateValue int64 `json:"dateValue,omitempty,string"`
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// ListValue: Represents a repeated `Value`.
                                                                                                                                                                                                                                                                                                                              	ListValue *ListValue `json:"listValue,omitempty"`
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// NullValue: Represents a null value.
                                                                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                                                                              	// Possible values:
                                                                                                                                                                                                                                                                                                                              	//   "NULL_VALUE" - Null value.
                                                                                                                                                                                                                                                                                                                              	NullValue string `json:"nullValue,omitempty"`
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// NumberValue: Represents a double value.
                                                                                                                                                                                                                                                                                                                              	NumberValue float64 `json:"numberValue,omitempty"`
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// ProtoValue: Represents a structured proto value.
                                                                                                                                                                                                                                                                                                                              	ProtoValue googleapi.RawMessage `json:"protoValue,omitempty"`
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// StringValue: Represents a string value.
                                                                                                                                                                                                                                                                                                                              	StringValue string `json:"stringValue,omitempty"`
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// StructValue: Represents a structured value.
                                                                                                                                                                                                                                                                                                                              	StructValue *Struct `json:"structValue,omitempty"`
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// ForceSendFields is a list of field names (e.g. "BoolValue") to
                                                                                                                                                                                                                                                                                                                              	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                                                                                                                                              	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                                                                                                                                              	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                                                                                                                                              	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                                                                                                                                              	// used to include empty fields in Patch requests.
                                                                                                                                                                                                                                                                                                                              	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                                                                              	// NullFields is a list of field names (e.g. "BoolValue") 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:"-"`
                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                Value: `Value` represents a dynamically typed value which is the outcome of an executed script Based on Value at: google3/apps/maestro/api/struct.proto?q=message%5c%20Value

                                                                                                                                                                                                                                                                                                                                func (*Value) MarshalJSON

                                                                                                                                                                                                                                                                                                                                func (s *Value) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                                                                                                                                                func (*Value) UnmarshalJSON

                                                                                                                                                                                                                                                                                                                                func (s *Value) UnmarshalJSON(data []byte) error

                                                                                                                                                                                                                                                                                                                                type Version

                                                                                                                                                                                                                                                                                                                                type Version struct {
                                                                                                                                                                                                                                                                                                                                	// CreateTime: When the version was created.
                                                                                                                                                                                                                                                                                                                                	CreateTime string `json:"createTime,omitempty"`
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// Description: The description for this version.
                                                                                                                                                                                                                                                                                                                                	Description string `json:"description,omitempty"`
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// ScriptId: The script project's Drive ID.
                                                                                                                                                                                                                                                                                                                                	ScriptId string `json:"scriptId,omitempty"`
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// VersionNumber: The incremental ID that is created by Apps Script when
                                                                                                                                                                                                                                                                                                                                	// a version is
                                                                                                                                                                                                                                                                                                                                	// created. This is system assigned number and is immutable once
                                                                                                                                                                                                                                                                                                                                	// created.
                                                                                                                                                                                                                                                                                                                                	VersionNumber int64 `json:"versionNumber,omitempty"`
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// ServerResponse contains the HTTP response code and headers from the
                                                                                                                                                                                                                                                                                                                                	// server.
                                                                                                                                                                                                                                                                                                                                	googleapi.ServerResponse `json:"-"`
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// ForceSendFields is a list of field names (e.g. "CreateTime") to
                                                                                                                                                                                                                                                                                                                                	// unconditionally include in API requests. By default, fields with
                                                                                                                                                                                                                                                                                                                                	// empty values are omitted from API requests. However, any non-pointer,
                                                                                                                                                                                                                                                                                                                                	// non-interface field appearing in ForceSendFields will be sent to the
                                                                                                                                                                                                                                                                                                                                	// server regardless of whether the field is empty or not. This may be
                                                                                                                                                                                                                                                                                                                                	// used to include empty fields in Patch requests.
                                                                                                                                                                                                                                                                                                                                	ForceSendFields []string `json:"-"`
                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                	// NullFields is a list of field names (e.g. "CreateTime") 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:"-"`
                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                  Version: A resource representing a script project version. A version is a "snapshot" of a script project and is similar to a read-only branched release. When creating deployments, the version to use must be specified.

                                                                                                                                                                                                                                                                                                                                  func (*Version) MarshalJSON

                                                                                                                                                                                                                                                                                                                                  func (s *Version) MarshalJSON() ([]byte, error)

                                                                                                                                                                                                                                                                                                                                  Source Files