| // Copyright 2024 Google LLC. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| // Code generated file. DO NOT EDIT. |
| |
| // Package gmail provides access to the Gmail API. |
| // |
| // For product documentation, see: https://developers.google.com/gmail/api/ |
| // |
| // # Library status |
| // |
| // These client libraries are officially supported by Google. However, this |
| // library is considered complete and is in maintenance mode. This means |
| // that we will address critical bugs and security issues but will not add |
| // any new features. |
| // |
| // When possible, we recommend using our newer |
| // [Cloud Client Libraries for Go](https://pkg.go.dev/cloud.google.com/go) |
| // that are still actively being worked and iterated on. |
| // |
| // # Creating a client |
| // |
| // Usage example: |
| // |
| // import "google.golang.org/api/gmail/v1" |
| // ... |
| // ctx := context.Background() |
| // gmailService, err := gmail.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 [google.golang.org/api/option.WithScopes]: |
| // |
| // gmailService, err := gmail.NewService(ctx, option.WithScopes(gmail.GmailSettingsSharingScope)) |
| // |
| // To use an API key for authentication (note: some APIs do not support API |
| // keys), use [google.golang.org/api/option.WithAPIKey]: |
| // |
| // gmailService, err := gmail.NewService(ctx, option.WithAPIKey("AIza...")) |
| // |
| // To use an OAuth token (e.g., a user token obtained via a three-legged OAuth |
| // flow, use [google.golang.org/api/option.WithTokenSource]: |
| // |
| // config := &oauth2.Config{...} |
| // // ... |
| // token, err := config.Exchange(ctx, ...) |
| // gmailService, err := gmail.NewService(ctx, option.WithTokenSource(config.TokenSource(ctx, token))) |
| // |
| // See [google.golang.org/api/option.ClientOption] for details on options. |
| package gmail // import "google.golang.org/api/gmail/v1" |
| |
| import ( |
| "bytes" |
| "context" |
| "encoding/json" |
| "errors" |
| "fmt" |
| "io" |
| "net/http" |
| "net/url" |
| "strconv" |
| "strings" |
| |
| googleapi "google.golang.org/api/googleapi" |
| internal "google.golang.org/api/internal" |
| gensupport "google.golang.org/api/internal/gensupport" |
| option "google.golang.org/api/option" |
| internaloption "google.golang.org/api/option/internaloption" |
| htransport "google.golang.org/api/transport/http" |
| ) |
| |
| // Always reference these packages, just in case the auto-generated code |
| // below doesn't. |
| var _ = bytes.NewBuffer |
| var _ = strconv.Itoa |
| var _ = fmt.Sprintf |
| var _ = json.NewDecoder |
| var _ = io.Copy |
| var _ = url.Parse |
| var _ = gensupport.MarshalJSON |
| var _ = googleapi.Version |
| var _ = errors.New |
| var _ = strings.Replace |
| var _ = context.Canceled |
| var _ = internaloption.WithDefaultEndpoint |
| var _ = internal.Version |
| |
| const apiId = "gmail:v1" |
| const apiName = "gmail" |
| const apiVersion = "v1" |
| const basePath = "https://gmail.googleapis.com/" |
| const basePathTemplate = "https://gmail.UNIVERSE_DOMAIN/" |
| const mtlsBasePath = "https://gmail.mtls.googleapis.com/" |
| |
| // OAuth2 scopes used by this API. |
| const ( |
| // Read, compose, send, and permanently delete all your email from Gmail |
| MailGoogleComScope = "https://mail.google.com/" |
| |
| // Manage drafts and send emails when you interact with the add-on |
| GmailAddonsCurrentActionComposeScope = "https://www.googleapis.com/auth/gmail.addons.current.action.compose" |
| |
| // View your email messages when you interact with the add-on |
| GmailAddonsCurrentMessageActionScope = "https://www.googleapis.com/auth/gmail.addons.current.message.action" |
| |
| // View your email message metadata when the add-on is running |
| GmailAddonsCurrentMessageMetadataScope = "https://www.googleapis.com/auth/gmail.addons.current.message.metadata" |
| |
| // View your email messages when the add-on is running |
| GmailAddonsCurrentMessageReadonlyScope = "https://www.googleapis.com/auth/gmail.addons.current.message.readonly" |
| |
| // Manage drafts and send emails |
| GmailComposeScope = "https://www.googleapis.com/auth/gmail.compose" |
| |
| // Add emails into your Gmail mailbox |
| GmailInsertScope = "https://www.googleapis.com/auth/gmail.insert" |
| |
| // See and edit your email labels |
| GmailLabelsScope = "https://www.googleapis.com/auth/gmail.labels" |
| |
| // View your email message metadata such as labels and headers, but not the |
| // email body |
| GmailMetadataScope = "https://www.googleapis.com/auth/gmail.metadata" |
| |
| // Read, compose, and send emails from your Gmail account |
| GmailModifyScope = "https://www.googleapis.com/auth/gmail.modify" |
| |
| // View your email messages and settings |
| GmailReadonlyScope = "https://www.googleapis.com/auth/gmail.readonly" |
| |
| // Send email on your behalf |
| GmailSendScope = "https://www.googleapis.com/auth/gmail.send" |
| |
| // See, edit, create, or change your email settings and filters in Gmail |
| GmailSettingsBasicScope = "https://www.googleapis.com/auth/gmail.settings.basic" |
| |
| // Manage your sensitive mail settings, including who can manage your mail |
| GmailSettingsSharingScope = "https://www.googleapis.com/auth/gmail.settings.sharing" |
| ) |
| |
| // NewService creates a new Service. |
| func NewService(ctx context.Context, opts ...option.ClientOption) (*Service, error) { |
| scopesOption := internaloption.WithDefaultScopes( |
| "https://mail.google.com/", |
| "https://www.googleapis.com/auth/gmail.addons.current.action.compose", |
| "https://www.googleapis.com/auth/gmail.addons.current.message.action", |
| "https://www.googleapis.com/auth/gmail.addons.current.message.metadata", |
| "https://www.googleapis.com/auth/gmail.addons.current.message.readonly", |
| "https://www.googleapis.com/auth/gmail.compose", |
| "https://www.googleapis.com/auth/gmail.insert", |
| "https://www.googleapis.com/auth/gmail.labels", |
| "https://www.googleapis.com/auth/gmail.metadata", |
| "https://www.googleapis.com/auth/gmail.modify", |
| "https://www.googleapis.com/auth/gmail.readonly", |
| "https://www.googleapis.com/auth/gmail.send", |
| "https://www.googleapis.com/auth/gmail.settings.basic", |
| "https://www.googleapis.com/auth/gmail.settings.sharing", |
| ) |
| // NOTE: prepend, so we don't override user-specified scopes. |
| opts = append([]option.ClientOption{scopesOption}, opts...) |
| opts = append(opts, internaloption.WithDefaultEndpoint(basePath)) |
| opts = append(opts, internaloption.WithDefaultEndpointTemplate(basePathTemplate)) |
| opts = append(opts, internaloption.WithDefaultMTLSEndpoint(mtlsBasePath)) |
| opts = append(opts, internaloption.EnableNewAuthLibrary()) |
| client, endpoint, err := htransport.NewClient(ctx, opts...) |
| if err != nil { |
| return nil, err |
| } |
| s, err := New(client) |
| if err != nil { |
| return nil, err |
| } |
| if endpoint != "" { |
| s.BasePath = endpoint |
| } |
| return s, nil |
| } |
| |
| // New creates a new 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 New(client *http.Client) (*Service, error) { |
| if client == nil { |
| return nil, errors.New("client is nil") |
| } |
| s := &Service{client: client, BasePath: basePath} |
| s.Users = NewUsersService(s) |
| return s, nil |
| } |
| |
| type Service struct { |
| client *http.Client |
| BasePath string // API endpoint base URL |
| UserAgent string // optional additional User-Agent fragment |
| |
| Users *UsersService |
| } |
| |
| func (s *Service) userAgent() string { |
| if s.UserAgent == "" { |
| return googleapi.UserAgent |
| } |
| return googleapi.UserAgent + " " + s.UserAgent |
| } |
| |
| func NewUsersService(s *Service) *UsersService { |
| rs := &UsersService{s: s} |
| rs.Drafts = NewUsersDraftsService(s) |
| rs.History = NewUsersHistoryService(s) |
| rs.Labels = NewUsersLabelsService(s) |
| rs.Messages = NewUsersMessagesService(s) |
| rs.Settings = NewUsersSettingsService(s) |
| rs.Threads = NewUsersThreadsService(s) |
| return rs |
| } |
| |
| type UsersService struct { |
| s *Service |
| |
| Drafts *UsersDraftsService |
| |
| History *UsersHistoryService |
| |
| Labels *UsersLabelsService |
| |
| Messages *UsersMessagesService |
| |
| Settings *UsersSettingsService |
| |
| Threads *UsersThreadsService |
| } |
| |
| func NewUsersDraftsService(s *Service) *UsersDraftsService { |
| rs := &UsersDraftsService{s: s} |
| return rs |
| } |
| |
| type UsersDraftsService struct { |
| s *Service |
| } |
| |
| func NewUsersHistoryService(s *Service) *UsersHistoryService { |
| rs := &UsersHistoryService{s: s} |
| return rs |
| } |
| |
| type UsersHistoryService struct { |
| s *Service |
| } |
| |
| func NewUsersLabelsService(s *Service) *UsersLabelsService { |
| rs := &UsersLabelsService{s: s} |
| return rs |
| } |
| |
| type UsersLabelsService struct { |
| s *Service |
| } |
| |
| func NewUsersMessagesService(s *Service) *UsersMessagesService { |
| rs := &UsersMessagesService{s: s} |
| rs.Attachments = NewUsersMessagesAttachmentsService(s) |
| return rs |
| } |
| |
| type UsersMessagesService struct { |
| s *Service |
| |
| Attachments *UsersMessagesAttachmentsService |
| } |
| |
| func NewUsersMessagesAttachmentsService(s *Service) *UsersMessagesAttachmentsService { |
| rs := &UsersMessagesAttachmentsService{s: s} |
| return rs |
| } |
| |
| type UsersMessagesAttachmentsService struct { |
| s *Service |
| } |
| |
| func NewUsersSettingsService(s *Service) *UsersSettingsService { |
| rs := &UsersSettingsService{s: s} |
| rs.Cse = NewUsersSettingsCseService(s) |
| rs.Delegates = NewUsersSettingsDelegatesService(s) |
| rs.Filters = NewUsersSettingsFiltersService(s) |
| rs.ForwardingAddresses = NewUsersSettingsForwardingAddressesService(s) |
| rs.SendAs = NewUsersSettingsSendAsService(s) |
| return rs |
| } |
| |
| type UsersSettingsService struct { |
| s *Service |
| |
| Cse *UsersSettingsCseService |
| |
| Delegates *UsersSettingsDelegatesService |
| |
| Filters *UsersSettingsFiltersService |
| |
| ForwardingAddresses *UsersSettingsForwardingAddressesService |
| |
| SendAs *UsersSettingsSendAsService |
| } |
| |
| func NewUsersSettingsCseService(s *Service) *UsersSettingsCseService { |
| rs := &UsersSettingsCseService{s: s} |
| rs.Identities = NewUsersSettingsCseIdentitiesService(s) |
| rs.Keypairs = NewUsersSettingsCseKeypairsService(s) |
| return rs |
| } |
| |
| type UsersSettingsCseService struct { |
| s *Service |
| |
| Identities *UsersSettingsCseIdentitiesService |
| |
| Keypairs *UsersSettingsCseKeypairsService |
| } |
| |
| func NewUsersSettingsCseIdentitiesService(s *Service) *UsersSettingsCseIdentitiesService { |
| rs := &UsersSettingsCseIdentitiesService{s: s} |
| return rs |
| } |
| |
| type UsersSettingsCseIdentitiesService struct { |
| s *Service |
| } |
| |
| func NewUsersSettingsCseKeypairsService(s *Service) *UsersSettingsCseKeypairsService { |
| rs := &UsersSettingsCseKeypairsService{s: s} |
| return rs |
| } |
| |
| type UsersSettingsCseKeypairsService struct { |
| s *Service |
| } |
| |
| func NewUsersSettingsDelegatesService(s *Service) *UsersSettingsDelegatesService { |
| rs := &UsersSettingsDelegatesService{s: s} |
| return rs |
| } |
| |
| type UsersSettingsDelegatesService struct { |
| s *Service |
| } |
| |
| func NewUsersSettingsFiltersService(s *Service) *UsersSettingsFiltersService { |
| rs := &UsersSettingsFiltersService{s: s} |
| return rs |
| } |
| |
| type UsersSettingsFiltersService struct { |
| s *Service |
| } |
| |
| func NewUsersSettingsForwardingAddressesService(s *Service) *UsersSettingsForwardingAddressesService { |
| rs := &UsersSettingsForwardingAddressesService{s: s} |
| return rs |
| } |
| |
| type UsersSettingsForwardingAddressesService struct { |
| s *Service |
| } |
| |
| func NewUsersSettingsSendAsService(s *Service) *UsersSettingsSendAsService { |
| rs := &UsersSettingsSendAsService{s: s} |
| rs.SmimeInfo = NewUsersSettingsSendAsSmimeInfoService(s) |
| return rs |
| } |
| |
| type UsersSettingsSendAsService struct { |
| s *Service |
| |
| SmimeInfo *UsersSettingsSendAsSmimeInfoService |
| } |
| |
| func NewUsersSettingsSendAsSmimeInfoService(s *Service) *UsersSettingsSendAsSmimeInfoService { |
| rs := &UsersSettingsSendAsSmimeInfoService{s: s} |
| return rs |
| } |
| |
| type UsersSettingsSendAsSmimeInfoService struct { |
| s *Service |
| } |
| |
| func NewUsersThreadsService(s *Service) *UsersThreadsService { |
| rs := &UsersThreadsService{s: s} |
| return rs |
| } |
| |
| type UsersThreadsService struct { |
| s *Service |
| } |
| |
| // AutoForwarding: Auto-forwarding settings for an account. |
| type AutoForwarding struct { |
| // Disposition: The state that a message should be left in after it has been |
| // forwarded. |
| // |
| // Possible values: |
| // "dispositionUnspecified" - Unspecified disposition. |
| // "leaveInInbox" - Leave the message in the `INBOX`. |
| // "archive" - Archive the message. |
| // "trash" - Move the message to the `TRASH`. |
| // "markRead" - Leave the message in the `INBOX` and mark it as read. |
| Disposition string `json:"disposition,omitempty"` |
| // EmailAddress: Email address to which all incoming messages are forwarded. |
| // This email address must be a verified member of the forwarding addresses. |
| EmailAddress string `json:"emailAddress,omitempty"` |
| // Enabled: Whether all incoming mail is automatically forwarded to another |
| // address. |
| Enabled bool `json:"enabled,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| // ForceSendFields is a list of field names (e.g. "Disposition") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "Disposition") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *AutoForwarding) MarshalJSON() ([]byte, error) { |
| type NoMethod AutoForwarding |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| type BatchDeleteMessagesRequest struct { |
| // Ids: The IDs of the messages to delete. |
| Ids []string `json:"ids,omitempty"` |
| // ForceSendFields is a list of field names (e.g. "Ids") to unconditionally |
| // include in API requests. By default, fields with empty or default values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "Ids") to include in API requests |
| // with the JSON null value. By default, fields with empty values are omitted |
| // from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *BatchDeleteMessagesRequest) MarshalJSON() ([]byte, error) { |
| type NoMethod BatchDeleteMessagesRequest |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| type BatchModifyMessagesRequest struct { |
| // AddLabelIds: A list of label IDs to add to messages. |
| AddLabelIds []string `json:"addLabelIds,omitempty"` |
| // Ids: The IDs of the messages to modify. There is a limit of 1000 ids per |
| // request. |
| Ids []string `json:"ids,omitempty"` |
| // RemoveLabelIds: A list of label IDs to remove from messages. |
| RemoveLabelIds []string `json:"removeLabelIds,omitempty"` |
| // ForceSendFields is a list of field names (e.g. "AddLabelIds") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "AddLabelIds") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *BatchModifyMessagesRequest) MarshalJSON() ([]byte, error) { |
| type NoMethod BatchModifyMessagesRequest |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // CseIdentity: The client-side encryption (CSE) configuration for the email |
| // address of an authenticated user. Gmail uses CSE configurations to save |
| // drafts of client-side encrypted email messages, and to sign and send |
| // encrypted email messages. |
| type CseIdentity struct { |
| // EmailAddress: The email address for the sending identity. The email address |
| // must be the primary email address of the authenticated user. |
| EmailAddress string `json:"emailAddress,omitempty"` |
| // PrimaryKeyPairId: If a key pair is associated, the ID of the key pair, |
| // CseKeyPair. |
| PrimaryKeyPairId string `json:"primaryKeyPairId,omitempty"` |
| // SignAndEncryptKeyPairs: The configuration of a CSE identity that uses |
| // different key pairs for signing and encryption. |
| SignAndEncryptKeyPairs *SignAndEncryptKeyPairs `json:"signAndEncryptKeyPairs,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| // ForceSendFields is a list of field names (e.g. "EmailAddress") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "EmailAddress") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *CseIdentity) MarshalJSON() ([]byte, error) { |
| type NoMethod CseIdentity |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // CseKeyPair: A client-side encryption S/MIME key pair, which is comprised of |
| // a public key, its certificate chain, and metadata for its paired private |
| // key. Gmail uses the key pair to complete the following tasks: - Sign |
| // outgoing client-side encrypted messages. - Save and reopen drafts of |
| // client-side encrypted messages. - Save and reopen sent messages. - Decrypt |
| // incoming or archived S/MIME messages. |
| type CseKeyPair struct { |
| // DisableTime: Output only. If a key pair is set to `DISABLED`, the time that |
| // the key pair's state changed from `ENABLED` to `DISABLED`. This field is |
| // present only when the key pair is in state `DISABLED`. |
| DisableTime string `json:"disableTime,omitempty"` |
| // EnablementState: Output only. The current state of the key pair. |
| // |
| // Possible values: |
| // "stateUnspecified" - The current state of the key pair is not set. The key |
| // pair is neither turned on nor turned off. |
| // "enabled" - The key pair is turned on. For any email messages that this |
| // key pair encrypts, Gmail decrypts the messages and signs any outgoing mail |
| // with the private key. To turn on a key pair, use the EnableCseKeyPair |
| // method. |
| // "disabled" - The key pair is turned off. Authenticated users cannot |
| // decrypt email messages nor sign outgoing messages. If a key pair is turned |
| // off for more than 30 days, you can permanently delete it. To turn off a key |
| // pair, use the DisableCseKeyPair method. |
| EnablementState string `json:"enablementState,omitempty"` |
| // KeyPairId: Output only. The immutable ID for the client-side encryption |
| // S/MIME key pair. |
| KeyPairId string `json:"keyPairId,omitempty"` |
| // Pem: Output only. The public key and its certificate chain, in PEM |
| // (https://en.wikipedia.org/wiki/Privacy-Enhanced_Mail) format. |
| Pem string `json:"pem,omitempty"` |
| // Pkcs7: Input only. The public key and its certificate chain. The chain must |
| // be in PKCS#7 (https://en.wikipedia.org/wiki/PKCS_7) format and use PEM |
| // encoding and ASCII armor. |
| Pkcs7 string `json:"pkcs7,omitempty"` |
| // PrivateKeyMetadata: Metadata for instances of this key pair's private key. |
| PrivateKeyMetadata []*CsePrivateKeyMetadata `json:"privateKeyMetadata,omitempty"` |
| // SubjectEmailAddresses: Output only. The email address identities that are |
| // specified on the leaf certificate. |
| SubjectEmailAddresses []string `json:"subjectEmailAddresses,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| // ForceSendFields is a list of field names (e.g. "DisableTime") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "DisableTime") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *CseKeyPair) MarshalJSON() ([]byte, error) { |
| type NoMethod CseKeyPair |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // CsePrivateKeyMetadata: Metadata for a private key instance. |
| type CsePrivateKeyMetadata struct { |
| // HardwareKeyMetadata: Metadata for hardware keys. |
| HardwareKeyMetadata *HardwareKeyMetadata `json:"hardwareKeyMetadata,omitempty"` |
| // KaclsKeyMetadata: Metadata for a private key instance managed by an external |
| // key access control list service. |
| KaclsKeyMetadata *KaclsKeyMetadata `json:"kaclsKeyMetadata,omitempty"` |
| // PrivateKeyMetadataId: Output only. The immutable ID for the private key |
| // metadata instance. |
| PrivateKeyMetadataId string `json:"privateKeyMetadataId,omitempty"` |
| // ForceSendFields is a list of field names (e.g. "HardwareKeyMetadata") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "HardwareKeyMetadata") to include |
| // in API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *CsePrivateKeyMetadata) MarshalJSON() ([]byte, error) { |
| type NoMethod CsePrivateKeyMetadata |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // Delegate: Settings for a delegate. Delegates can read, send, and delete |
| // messages, as well as view and add contacts, for the delegator's account. See |
| // "Set up mail delegation" for more information about delegates. |
| type Delegate struct { |
| // DelegateEmail: The email address of the delegate. |
| DelegateEmail string `json:"delegateEmail,omitempty"` |
| // VerificationStatus: Indicates whether this address has been verified and can |
| // act as a delegate for the account. Read-only. |
| // |
| // Possible values: |
| // "verificationStatusUnspecified" - Unspecified verification status. |
| // "accepted" - The address can act a delegate for the account. |
| // "pending" - A verification request was mailed to the address, and the |
| // owner has not yet accepted it. |
| // "rejected" - A verification request was mailed to the address, and the |
| // owner rejected it. |
| // "expired" - A verification request was mailed to the address, and it |
| // expired without verification. |
| VerificationStatus string `json:"verificationStatus,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| // ForceSendFields is a list of field names (e.g. "DelegateEmail") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "DelegateEmail") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Delegate) MarshalJSON() ([]byte, error) { |
| type NoMethod Delegate |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // DisableCseKeyPairRequest: Requests to turn off a client-side encryption key |
| // pair. |
| type DisableCseKeyPairRequest struct { |
| } |
| |
| // Draft: A draft email in the user's mailbox. |
| type Draft struct { |
| // Id: The immutable ID of the draft. |
| Id string `json:"id,omitempty"` |
| // Message: The message content of the draft. |
| Message *Message `json:"message,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| // ForceSendFields is a list of field names (e.g. "Id") to unconditionally |
| // include in API requests. By default, fields with empty or default values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "Id") to include in API requests |
| // with the JSON null value. By default, fields with empty values are omitted |
| // from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Draft) MarshalJSON() ([]byte, error) { |
| type NoMethod Draft |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // EnableCseKeyPairRequest: Requests to turn on a client-side encryption key |
| // pair. |
| type EnableCseKeyPairRequest struct { |
| } |
| |
| // Filter: Resource definition for Gmail filters. Filters apply to specific |
| // messages instead of an entire email thread. |
| type Filter struct { |
| // Action: Action that the filter performs. |
| Action *FilterAction `json:"action,omitempty"` |
| // Criteria: Matching criteria for the filter. |
| Criteria *FilterCriteria `json:"criteria,omitempty"` |
| // Id: The server assigned ID of the filter. |
| Id string `json:"id,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| // ForceSendFields is a list of field names (e.g. "Action") to unconditionally |
| // include in API requests. By default, fields with empty or default values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "Action") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Filter) MarshalJSON() ([]byte, error) { |
| type NoMethod Filter |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // FilterAction: A set of actions to perform on a message. |
| type FilterAction struct { |
| // AddLabelIds: List of labels to add to the message. |
| AddLabelIds []string `json:"addLabelIds,omitempty"` |
| // Forward: Email address that the message should be forwarded to. |
| Forward string `json:"forward,omitempty"` |
| // RemoveLabelIds: List of labels to remove from the message. |
| RemoveLabelIds []string `json:"removeLabelIds,omitempty"` |
| // ForceSendFields is a list of field names (e.g. "AddLabelIds") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "AddLabelIds") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *FilterAction) MarshalJSON() ([]byte, error) { |
| type NoMethod FilterAction |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // FilterCriteria: Message matching criteria. |
| type FilterCriteria struct { |
| // ExcludeChats: Whether the response should exclude chats. |
| ExcludeChats bool `json:"excludeChats,omitempty"` |
| // From: The sender's display name or email address. |
| From string `json:"from,omitempty"` |
| // HasAttachment: Whether the message has any attachment. |
| HasAttachment bool `json:"hasAttachment,omitempty"` |
| // NegatedQuery: Only return messages not matching the specified query. |
| // Supports the same query format as the Gmail search box. For example, |
| // "from:someuser@example.com rfc822msgid: is:unread". |
| NegatedQuery string `json:"negatedQuery,omitempty"` |
| // Query: Only return messages matching the specified query. Supports the same |
| // query format as the Gmail search box. For example, |
| // "from:someuser@example.com rfc822msgid: is:unread". |
| Query string `json:"query,omitempty"` |
| // Size: The size of the entire RFC822 message in bytes, including all headers |
| // and attachments. |
| Size int64 `json:"size,omitempty"` |
| // SizeComparison: How the message size in bytes should be in relation to the |
| // size field. |
| // |
| // Possible values: |
| // "unspecified" |
| // "smaller" - Find messages smaller than the given size. |
| // "larger" - Find messages larger than the given size. |
| SizeComparison string `json:"sizeComparison,omitempty"` |
| // Subject: Case-insensitive phrase found in the message's subject. Trailing |
| // and leading whitespace are be trimmed and adjacent spaces are collapsed. |
| Subject string `json:"subject,omitempty"` |
| // To: The recipient's display name or email address. Includes recipients in |
| // the "to", "cc", and "bcc" header fields. You can use simply the local part |
| // of the email address. For example, "example" and "example@" both match |
| // "example@gmail.com". This field is case-insensitive. |
| To string `json:"to,omitempty"` |
| // ForceSendFields is a list of field names (e.g. "ExcludeChats") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "ExcludeChats") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *FilterCriteria) MarshalJSON() ([]byte, error) { |
| type NoMethod FilterCriteria |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // ForwardingAddress: Settings for a forwarding address. |
| type ForwardingAddress struct { |
| // ForwardingEmail: An email address to which messages can be forwarded. |
| ForwardingEmail string `json:"forwardingEmail,omitempty"` |
| // VerificationStatus: Indicates whether this address has been verified and is |
| // usable for forwarding. Read-only. |
| // |
| // Possible values: |
| // "verificationStatusUnspecified" - Unspecified verification status. |
| // "accepted" - The address is ready to use for forwarding. |
| // "pending" - The address is awaiting verification by the owner. |
| VerificationStatus string `json:"verificationStatus,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| // ForceSendFields is a list of field names (e.g. "ForwardingEmail") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "ForwardingEmail") to include in |
| // API requests with the JSON null value. By default, fields with empty values |
| // are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ForwardingAddress) MarshalJSON() ([]byte, error) { |
| type NoMethod ForwardingAddress |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // HardwareKeyMetadata: Metadata for hardware keys. |
| type HardwareKeyMetadata struct { |
| // Description: Description about the hardware key. |
| Description string `json:"description,omitempty"` |
| // ForceSendFields is a list of field names (e.g. "Description") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| 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. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *HardwareKeyMetadata) MarshalJSON() ([]byte, error) { |
| type NoMethod HardwareKeyMetadata |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // History: A record of a change to the user's mailbox. Each history change may |
| // affect multiple messages in multiple ways. |
| type History struct { |
| // Id: The mailbox sequence ID. |
| Id uint64 `json:"id,omitempty,string"` |
| // LabelsAdded: Labels added to messages in this history record. |
| LabelsAdded []*HistoryLabelAdded `json:"labelsAdded,omitempty"` |
| // LabelsRemoved: Labels removed from messages in this history record. |
| LabelsRemoved []*HistoryLabelRemoved `json:"labelsRemoved,omitempty"` |
| // Messages: List of messages changed in this history record. The fields for |
| // specific change types, such as `messagesAdded` may duplicate messages in |
| // this field. We recommend using the specific change-type fields instead of |
| // this. |
| Messages []*Message `json:"messages,omitempty"` |
| // MessagesAdded: Messages added to the mailbox in this history record. |
| MessagesAdded []*HistoryMessageAdded `json:"messagesAdded,omitempty"` |
| // MessagesDeleted: Messages deleted (not Trashed) from the mailbox in this |
| // history record. |
| MessagesDeleted []*HistoryMessageDeleted `json:"messagesDeleted,omitempty"` |
| // ForceSendFields is a list of field names (e.g. "Id") to unconditionally |
| // include in API requests. By default, fields with empty or default values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "Id") to include in API requests |
| // with the JSON null value. By default, fields with empty values are omitted |
| // from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *History) MarshalJSON() ([]byte, error) { |
| type NoMethod History |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| type HistoryLabelAdded struct { |
| // LabelIds: Label IDs added to the message. |
| LabelIds []string `json:"labelIds,omitempty"` |
| Message *Message `json:"message,omitempty"` |
| // ForceSendFields is a list of field names (e.g. "LabelIds") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "LabelIds") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *HistoryLabelAdded) MarshalJSON() ([]byte, error) { |
| type NoMethod HistoryLabelAdded |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| type HistoryLabelRemoved struct { |
| // LabelIds: Label IDs removed from the message. |
| LabelIds []string `json:"labelIds,omitempty"` |
| Message *Message `json:"message,omitempty"` |
| // ForceSendFields is a list of field names (e.g. "LabelIds") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "LabelIds") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *HistoryLabelRemoved) MarshalJSON() ([]byte, error) { |
| type NoMethod HistoryLabelRemoved |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| type HistoryMessageAdded struct { |
| Message *Message `json:"message,omitempty"` |
| // ForceSendFields is a list of field names (e.g. "Message") to unconditionally |
| // include in API requests. By default, fields with empty or default values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "Message") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *HistoryMessageAdded) MarshalJSON() ([]byte, error) { |
| type NoMethod HistoryMessageAdded |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| type HistoryMessageDeleted struct { |
| Message *Message `json:"message,omitempty"` |
| // ForceSendFields is a list of field names (e.g. "Message") to unconditionally |
| // include in API requests. By default, fields with empty or default values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "Message") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *HistoryMessageDeleted) MarshalJSON() ([]byte, error) { |
| type NoMethod HistoryMessageDeleted |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // ImapSettings: IMAP settings for an account. |
| type ImapSettings struct { |
| // AutoExpunge: If this value is true, Gmail will immediately expunge a message |
| // when it is marked as deleted in IMAP. Otherwise, Gmail will wait for an |
| // update from the client before expunging messages marked as deleted. |
| AutoExpunge bool `json:"autoExpunge,omitempty"` |
| // Enabled: Whether IMAP is enabled for the account. |
| Enabled bool `json:"enabled,omitempty"` |
| // ExpungeBehavior: The action that will be executed on a message when it is |
| // marked as deleted and expunged from the last visible IMAP folder. |
| // |
| // Possible values: |
| // "expungeBehaviorUnspecified" - Unspecified behavior. |
| // "archive" - Archive messages marked as deleted. |
| // "trash" - Move messages marked as deleted to the trash. |
| // "deleteForever" - Immediately and permanently delete messages marked as |
| // deleted. The expunged messages cannot be recovered. |
| ExpungeBehavior string `json:"expungeBehavior,omitempty"` |
| // MaxFolderSize: An optional limit on the number of messages that an IMAP |
| // folder may contain. Legal values are 0, 1000, 2000, 5000 or 10000. A value |
| // of zero is interpreted to mean that there is no limit. |
| MaxFolderSize int64 `json:"maxFolderSize,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| // ForceSendFields is a list of field names (e.g. "AutoExpunge") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "AutoExpunge") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ImapSettings) MarshalJSON() ([]byte, error) { |
| type NoMethod ImapSettings |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // KaclsKeyMetadata: Metadata for private keys managed by an external key |
| // access control list service. For details about managing key access, see |
| // Google Workspace CSE API Reference |
| // (https://developers.google.com/workspace/cse/reference). |
| type KaclsKeyMetadata struct { |
| // KaclsData: Opaque data generated and used by the key access control list |
| // service. Maximum size: 8 KiB. |
| KaclsData string `json:"kaclsData,omitempty"` |
| // KaclsUri: The URI of the key access control list service that manages the |
| // private key. |
| KaclsUri string `json:"kaclsUri,omitempty"` |
| // ForceSendFields is a list of field names (e.g. "KaclsData") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "KaclsData") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *KaclsKeyMetadata) MarshalJSON() ([]byte, error) { |
| type NoMethod KaclsKeyMetadata |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // Label: Labels are used to categorize messages and threads within the user's |
| // mailbox. The maximum number of labels supported for a user's mailbox is |
| // 10,000. |
| type Label struct { |
| // Color: The color to assign to the label. Color is only available for labels |
| // that have their `type` set to `user`. |
| Color *LabelColor `json:"color,omitempty"` |
| // Id: The immutable ID of the label. |
| Id string `json:"id,omitempty"` |
| // LabelListVisibility: The visibility of the label in the label list in the |
| // Gmail web interface. |
| // |
| // Possible values: |
| // "labelShow" - Show the label in the label list. |
| // "labelShowIfUnread" - Show the label if there are any unread messages with |
| // that label. |
| // "labelHide" - Do not show the label in the label list. |
| LabelListVisibility string `json:"labelListVisibility,omitempty"` |
| // MessageListVisibility: The visibility of messages with this label in the |
| // message list in the Gmail web interface. |
| // |
| // Possible values: |
| // "show" - Show the label in the message list. |
| // "hide" - Do not show the label in the message list. |
| MessageListVisibility string `json:"messageListVisibility,omitempty"` |
| // MessagesTotal: The total number of messages with the label. |
| MessagesTotal int64 `json:"messagesTotal,omitempty"` |
| // MessagesUnread: The number of unread messages with the label. |
| MessagesUnread int64 `json:"messagesUnread,omitempty"` |
| // Name: The display name of the label. |
| Name string `json:"name,omitempty"` |
| // ThreadsTotal: The total number of threads with the label. |
| ThreadsTotal int64 `json:"threadsTotal,omitempty"` |
| // ThreadsUnread: The number of unread threads with the label. |
| ThreadsUnread int64 `json:"threadsUnread,omitempty"` |
| // Type: The owner type for the label. User labels are created by the user and |
| // can be modified and deleted by the user and can be applied to any message or |
| // thread. System labels are internally created and cannot be added, modified, |
| // or deleted. System labels may be able to be applied to or removed from |
| // messages and threads under some circumstances but this is not guaranteed. |
| // For example, users can apply and remove the `INBOX` and `UNREAD` labels from |
| // messages and threads, but cannot apply or remove the `DRAFTS` or `SENT` |
| // labels from messages or threads. |
| // |
| // Possible values: |
| // "system" - Labels created by Gmail. |
| // "user" - Custom labels created by the user or application. |
| Type string `json:"type,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| // ForceSendFields is a list of field names (e.g. "Color") to unconditionally |
| // include in API requests. By default, fields with empty or default values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "Color") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Label) MarshalJSON() ([]byte, error) { |
| type NoMethod Label |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| type LabelColor struct { |
| // BackgroundColor: The background color represented as hex string #RRGGBB (ex |
| // #000000). This field is required in order to set the color of a label. Only |
| // the following predefined set of color values are allowed: \#000000, #434343, |
| // #666666, #999999, #cccccc, #efefef, #f3f3f3, #ffffff, \#fb4c2f, #ffad47, |
| // #fad165, #16a766, #43d692, #4a86e8, #a479e2, #f691b3, \#f6c5be, #ffe6c7, |
| // #fef1d1, #b9e4d0, #c6f3de, #c9daf8, #e4d7f5, #fcdee8, \#efa093, #ffd6a2, |
| // #fce8b3, #89d3b2, #a0eac9, #a4c2f4, #d0bcf1, #fbc8d9, \#e66550, #ffbc6b, |
| // #fcda83, #44b984, #68dfa9, #6d9eeb, #b694e8, #f7a7c0, \#cc3a21, #eaa041, |
| // #f2c960, #149e60, #3dc789, #3c78d8, #8e63ce, #e07798, \#ac2b16, #cf8933, |
| // #d5ae49, #0b804b, #2a9c68, #285bac, #653e9b, #b65775, \#822111, #a46a21, |
| // #aa8831, #076239, #1a764d, #1c4587, #41236d, #83334c \#464646, #e7e7e7, |
| // #0d3472, #b6cff5, #0d3b44, #98d7e4, #3d188e, #e3d7ff, \#711a36, #fbd3e0, |
| // #8a1c0a, #f2b2a8, #7a2e0b, #ffc8af, #7a4706, #ffdeb5, \#594c05, #fbe983, |
| // #684e07, #fdedc1, #0b4f30, #b3efd3, #04502e, #a2dcc1, \#c2c2c2, #4986e7, |
| // #2da2bb, #b99aff, #994a64, #f691b2, #ff7537, #ffad46, \#662e37, #ebdbde, |
| // #cca6ac, #094228, #42d692, #16a765 |
| BackgroundColor string `json:"backgroundColor,omitempty"` |
| // TextColor: The text color of the label, represented as hex string. This |
| // field is required in order to set the color of a label. Only the following |
| // predefined set of color values are allowed: \#000000, #434343, #666666, |
| // #999999, #cccccc, #efefef, #f3f3f3, #ffffff, \#fb4c2f, #ffad47, #fad165, |
| // #16a766, #43d692, #4a86e8, #a479e2, #f691b3, \#f6c5be, #ffe6c7, #fef1d1, |
| // #b9e4d0, #c6f3de, #c9daf8, #e4d7f5, #fcdee8, \#efa093, #ffd6a2, #fce8b3, |
| // #89d3b2, #a0eac9, #a4c2f4, #d0bcf1, #fbc8d9, \#e66550, #ffbc6b, #fcda83, |
| // #44b984, #68dfa9, #6d9eeb, #b694e8, #f7a7c0, \#cc3a21, #eaa041, #f2c960, |
| // #149e60, #3dc789, #3c78d8, #8e63ce, #e07798, \#ac2b16, #cf8933, #d5ae49, |
| // #0b804b, #2a9c68, #285bac, #653e9b, #b65775, \#822111, #a46a21, #aa8831, |
| // #076239, #1a764d, #1c4587, #41236d, #83334c \#464646, #e7e7e7, #0d3472, |
| // #b6cff5, #0d3b44, #98d7e4, #3d188e, #e3d7ff, \#711a36, #fbd3e0, #8a1c0a, |
| // #f2b2a8, #7a2e0b, #ffc8af, #7a4706, #ffdeb5, \#594c05, #fbe983, #684e07, |
| // #fdedc1, #0b4f30, #b3efd3, #04502e, #a2dcc1, \#c2c2c2, #4986e7, #2da2bb, |
| // #b99aff, #994a64, #f691b2, #ff7537, #ffad46, \#662e37, #ebdbde, #cca6ac, |
| // #094228, #42d692, #16a765 |
| TextColor string `json:"textColor,omitempty"` |
| // ForceSendFields is a list of field names (e.g. "BackgroundColor") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "BackgroundColor") to include in |
| // API requests with the JSON null value. By default, fields with empty values |
| // are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *LabelColor) MarshalJSON() ([]byte, error) { |
| type NoMethod LabelColor |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // LanguageSettings: Language settings for an account. These settings |
| // correspond to the "Language settings" feature in the web interface. |
| type LanguageSettings struct { |
| // DisplayLanguage: The language to display Gmail in, formatted as an RFC 3066 |
| // Language Tag (for example `en-GB`, `fr` or `ja` for British English, French, |
| // or Japanese respectively). The set of languages supported by Gmail evolves |
| // over time, so please refer to the "Language" dropdown in the Gmail settings |
| // for all available options, as described in the language settings help |
| // article. A table of sample values is also provided in the Managing Language |
| // Settings guide Not all Gmail clients can display the same set of languages. |
| // In the case that a user's display language is not available for use on a |
| // particular client, said client automatically chooses to display in the |
| // closest supported variant (or a reasonable default). |
| DisplayLanguage string `json:"displayLanguage,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| // ForceSendFields is a list of field names (e.g. "DisplayLanguage") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "DisplayLanguage") to include in |
| // API requests with the JSON null value. By default, fields with empty values |
| // are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *LanguageSettings) MarshalJSON() ([]byte, error) { |
| type NoMethod LanguageSettings |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| type ListCseIdentitiesResponse struct { |
| // CseIdentities: One page of the list of CSE identities configured for the |
| // user. |
| CseIdentities []*CseIdentity `json:"cseIdentities,omitempty"` |
| // NextPageToken: Pagination token to be passed to a subsequent |
| // ListCseIdentities call in order to retrieve the next page of identities. If |
| // this value is not returned or is the empty string, then no further pages |
| // remain. |
| 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. "CseIdentities") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "CseIdentities") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListCseIdentitiesResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod ListCseIdentitiesResponse |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| type ListCseKeyPairsResponse struct { |
| // CseKeyPairs: One page of the list of CSE key pairs installed for the user. |
| CseKeyPairs []*CseKeyPair `json:"cseKeyPairs,omitempty"` |
| // NextPageToken: Pagination token to be passed to a subsequent ListCseKeyPairs |
| // call in order to retrieve the next page of key pairs. If this value is not |
| // returned, then no further pages remain. |
| 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. "CseKeyPairs") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "CseKeyPairs") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListCseKeyPairsResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod ListCseKeyPairsResponse |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // ListDelegatesResponse: Response for the ListDelegates method. |
| type ListDelegatesResponse struct { |
| // Delegates: List of the user's delegates (with any verification status). If |
| // an account doesn't have delegates, this field doesn't appear. |
| Delegates []*Delegate `json:"delegates,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| // ForceSendFields is a list of field names (e.g. "Delegates") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "Delegates") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListDelegatesResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod ListDelegatesResponse |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| type ListDraftsResponse struct { |
| // Drafts: List of drafts. Note that the `Message` property in each `Draft` |
| // resource only contains an `id` and a `threadId`. The messages.get method can |
| // fetch additional message details. |
| Drafts []*Draft `json:"drafts,omitempty"` |
| // NextPageToken: Token to retrieve the next page of results in the list. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| // ResultSizeEstimate: Estimated total number of results. |
| ResultSizeEstimate int64 `json:"resultSizeEstimate,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| // ForceSendFields is a list of field names (e.g. "Drafts") to unconditionally |
| // include in API requests. By default, fields with empty or default values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "Drafts") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListDraftsResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod ListDraftsResponse |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // ListFiltersResponse: Response for the ListFilters method. |
| type ListFiltersResponse struct { |
| // Filter: List of a user's filters. |
| Filter []*Filter `json:"filter,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| // ForceSendFields is a list of field names (e.g. "Filter") to unconditionally |
| // include in API requests. By default, fields with empty or default values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "Filter") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListFiltersResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod ListFiltersResponse |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // ListForwardingAddressesResponse: Response for the ListForwardingAddresses |
| // method. |
| type ListForwardingAddressesResponse struct { |
| // ForwardingAddresses: List of addresses that may be used for forwarding. |
| ForwardingAddresses []*ForwardingAddress `json:"forwardingAddresses,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| // ForceSendFields is a list of field names (e.g. "ForwardingAddresses") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "ForwardingAddresses") to include |
| // in API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListForwardingAddressesResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod ListForwardingAddressesResponse |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| type ListHistoryResponse struct { |
| // History: List of history records. Any `messages` contained in the response |
| // will typically only have `id` and `threadId` fields populated. |
| History []*History `json:"history,omitempty"` |
| // HistoryId: The ID of the mailbox's current history record. |
| HistoryId uint64 `json:"historyId,omitempty,string"` |
| // NextPageToken: Page token to retrieve the next page of results in the list. |
| 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. "History") to unconditionally |
| // include in API requests. By default, fields with empty or default values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "History") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListHistoryResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod ListHistoryResponse |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| type ListLabelsResponse struct { |
| // Labels: List of labels. Note that each label resource only contains an `id`, |
| // `name`, `messageListVisibility`, `labelListVisibility`, and `type`. The |
| // labels.get method can fetch additional label details. |
| Labels []*Label `json:"labels,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| // ForceSendFields is a list of field names (e.g. "Labels") to unconditionally |
| // include in API requests. By default, fields with empty or default values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "Labels") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListLabelsResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod ListLabelsResponse |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| type ListMessagesResponse struct { |
| // Messages: List of messages. Note that each message resource contains only an |
| // `id` and a `threadId`. Additional message details can be fetched using the |
| // messages.get method. |
| Messages []*Message `json:"messages,omitempty"` |
| // NextPageToken: Token to retrieve the next page of results in the list. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| // ResultSizeEstimate: Estimated total number of results. |
| ResultSizeEstimate int64 `json:"resultSizeEstimate,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| // ForceSendFields is a list of field names (e.g. "Messages") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "Messages") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListMessagesResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod ListMessagesResponse |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // ListSendAsResponse: Response for the ListSendAs method. |
| type ListSendAsResponse struct { |
| // SendAs: List of send-as aliases. |
| SendAs []*SendAs `json:"sendAs,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| // ForceSendFields is a list of field names (e.g. "SendAs") to unconditionally |
| // include in API requests. By default, fields with empty or default values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "SendAs") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListSendAsResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod ListSendAsResponse |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| type ListSmimeInfoResponse struct { |
| // SmimeInfo: List of SmimeInfo. |
| SmimeInfo []*SmimeInfo `json:"smimeInfo,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| // ForceSendFields is a list of field names (e.g. "SmimeInfo") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "SmimeInfo") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListSmimeInfoResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod ListSmimeInfoResponse |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| type ListThreadsResponse struct { |
| // NextPageToken: Page token to retrieve the next page of results in the list. |
| NextPageToken string `json:"nextPageToken,omitempty"` |
| // ResultSizeEstimate: Estimated total number of results. |
| ResultSizeEstimate int64 `json:"resultSizeEstimate,omitempty"` |
| // Threads: List of threads. Note that each thread resource does not contain a |
| // list of `messages`. The list of `messages` for a given thread can be fetched |
| // using the threads.get method. |
| Threads []*Thread `json:"threads,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 or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| 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. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ListThreadsResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod ListThreadsResponse |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // Message: An email message. |
| type Message struct { |
| // HistoryId: The ID of the last history record that modified this message. |
| HistoryId uint64 `json:"historyId,omitempty,string"` |
| // Id: The immutable ID of the message. |
| Id string `json:"id,omitempty"` |
| // InternalDate: The internal message creation timestamp (epoch ms), which |
| // determines ordering in the inbox. For normal SMTP-received email, this |
| // represents the time the message was originally accepted by Google, which is |
| // more reliable than the `Date` header. However, for API-migrated mail, it can |
| // be configured by client to be based on the `Date` header. |
| InternalDate int64 `json:"internalDate,omitempty,string"` |
| // LabelIds: List of IDs of labels applied to this message. |
| LabelIds []string `json:"labelIds,omitempty"` |
| // Payload: The parsed email structure in the message parts. |
| Payload *MessagePart `json:"payload,omitempty"` |
| // Raw: The entire email message in an RFC 2822 formatted and base64url encoded |
| // string. Returned in `messages.get` and `drafts.get` responses when the |
| // `format=RAW` parameter is supplied. |
| Raw string `json:"raw,omitempty"` |
| // SizeEstimate: Estimated size in bytes of the message. |
| SizeEstimate int64 `json:"sizeEstimate,omitempty"` |
| // Snippet: A short part of the message text. |
| Snippet string `json:"snippet,omitempty"` |
| // ThreadId: The ID of the thread the message belongs to. To add a message or |
| // draft to a thread, the following criteria must be met: 1. The requested |
| // `threadId` must be specified on the `Message` or `Draft.Message` you supply |
| // with your request. 2. The `References` and `In-Reply-To` headers must be set |
| // in compliance with the RFC 2822 (https://tools.ietf.org/html/rfc2822) |
| // standard. 3. The `Subject` headers must match. |
| ThreadId string `json:"threadId,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| // ForceSendFields is a list of field names (e.g. "HistoryId") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "HistoryId") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Message) MarshalJSON() ([]byte, error) { |
| type NoMethod Message |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // MessagePart: A single MIME message part. |
| type MessagePart struct { |
| // Body: The message part body for this part, which may be empty for container |
| // MIME message parts. |
| Body *MessagePartBody `json:"body,omitempty"` |
| // Filename: The filename of the attachment. Only present if this message part |
| // represents an attachment. |
| Filename string `json:"filename,omitempty"` |
| // Headers: List of headers on this message part. For the top-level message |
| // part, representing the entire message payload, it will contain the standard |
| // RFC 2822 email headers such as `To`, `From`, and `Subject`. |
| Headers []*MessagePartHeader `json:"headers,omitempty"` |
| // MimeType: The MIME type of the message part. |
| MimeType string `json:"mimeType,omitempty"` |
| // PartId: The immutable ID of the message part. |
| PartId string `json:"partId,omitempty"` |
| // Parts: The child MIME message parts of this part. This only applies to |
| // container MIME message parts, for example `multipart/*`. For non- container |
| // MIME message part types, such as `text/plain`, this field is empty. For more |
| // information, see RFC 1521. |
| Parts []*MessagePart `json:"parts,omitempty"` |
| // ForceSendFields is a list of field names (e.g. "Body") to unconditionally |
| // include in API requests. By default, fields with empty or default values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "Body") to include in API requests |
| // with the JSON null value. By default, fields with empty values are omitted |
| // from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *MessagePart) MarshalJSON() ([]byte, error) { |
| type NoMethod MessagePart |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // MessagePartBody: The body of a single MIME message part. |
| type MessagePartBody struct { |
| // AttachmentId: When present, contains the ID of an external attachment that |
| // can be retrieved in a separate `messages.attachments.get` request. When not |
| // present, the entire content of the message part body is contained in the |
| // data field. |
| AttachmentId string `json:"attachmentId,omitempty"` |
| // Data: The body data of a MIME message part as a base64url encoded string. |
| // May be empty for MIME container types that have no message body or when the |
| // body data is sent as a separate attachment. An attachment ID is present if |
| // the body data is contained in a separate attachment. |
| Data string `json:"data,omitempty"` |
| // Size: Number of bytes for the message part data (encoding notwithstanding). |
| Size int64 `json:"size,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| // ForceSendFields is a list of field names (e.g. "AttachmentId") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "AttachmentId") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *MessagePartBody) MarshalJSON() ([]byte, error) { |
| type NoMethod MessagePartBody |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| type MessagePartHeader struct { |
| // Name: The name of the header before the `:` separator. For example, `To`. |
| Name string `json:"name,omitempty"` |
| // Value: The value of the header after the `:` separator. For example, |
| // `someuser@example.com`. |
| Value string `json:"value,omitempty"` |
| // ForceSendFields is a list of field names (e.g. "Name") to unconditionally |
| // include in API requests. By default, fields with empty or default values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| 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. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *MessagePartHeader) MarshalJSON() ([]byte, error) { |
| type NoMethod MessagePartHeader |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| type ModifyMessageRequest struct { |
| // AddLabelIds: A list of IDs of labels to add to this message. You can add up |
| // to 100 labels with each update. |
| AddLabelIds []string `json:"addLabelIds,omitempty"` |
| // RemoveLabelIds: A list IDs of labels to remove from this message. You can |
| // remove up to 100 labels with each update. |
| RemoveLabelIds []string `json:"removeLabelIds,omitempty"` |
| // ForceSendFields is a list of field names (e.g. "AddLabelIds") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "AddLabelIds") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ModifyMessageRequest) MarshalJSON() ([]byte, error) { |
| type NoMethod ModifyMessageRequest |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| type ModifyThreadRequest struct { |
| // AddLabelIds: A list of IDs of labels to add to this thread. You can add up |
| // to 100 labels with each update. |
| AddLabelIds []string `json:"addLabelIds,omitempty"` |
| // RemoveLabelIds: A list of IDs of labels to remove from this thread. You can |
| // remove up to 100 labels with each update. |
| RemoveLabelIds []string `json:"removeLabelIds,omitempty"` |
| // ForceSendFields is a list of field names (e.g. "AddLabelIds") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "AddLabelIds") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *ModifyThreadRequest) MarshalJSON() ([]byte, error) { |
| type NoMethod ModifyThreadRequest |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // ObliterateCseKeyPairRequest: Request to obliterate a CSE key pair. |
| type ObliterateCseKeyPairRequest struct { |
| } |
| |
| // PopSettings: POP settings for an account. |
| type PopSettings struct { |
| // AccessWindow: The range of messages which are accessible via POP. |
| // |
| // Possible values: |
| // "accessWindowUnspecified" - Unspecified range. |
| // "disabled" - Indicates that no messages are accessible via POP. |
| // "fromNowOn" - Indicates that unfetched messages received after some past |
| // point in time are accessible via POP. |
| // "allMail" - Indicates that all unfetched messages are accessible via POP. |
| AccessWindow string `json:"accessWindow,omitempty"` |
| // Disposition: The action that will be executed on a message after it has been |
| // fetched via POP. |
| // |
| // Possible values: |
| // "dispositionUnspecified" - Unspecified disposition. |
| // "leaveInInbox" - Leave the message in the `INBOX`. |
| // "archive" - Archive the message. |
| // "trash" - Move the message to the `TRASH`. |
| // "markRead" - Leave the message in the `INBOX` and mark it as read. |
| Disposition string `json:"disposition,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| // ForceSendFields is a list of field names (e.g. "AccessWindow") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "AccessWindow") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *PopSettings) MarshalJSON() ([]byte, error) { |
| type NoMethod PopSettings |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // Profile: Profile for a Gmail user. |
| type Profile struct { |
| // EmailAddress: The user's email address. |
| EmailAddress string `json:"emailAddress,omitempty"` |
| // HistoryId: The ID of the mailbox's current history record. |
| HistoryId uint64 `json:"historyId,omitempty,string"` |
| // MessagesTotal: The total number of messages in the mailbox. |
| MessagesTotal int64 `json:"messagesTotal,omitempty"` |
| // ThreadsTotal: The total number of threads in the mailbox. |
| ThreadsTotal int64 `json:"threadsTotal,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| // ForceSendFields is a list of field names (e.g. "EmailAddress") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "EmailAddress") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Profile) MarshalJSON() ([]byte, error) { |
| type NoMethod Profile |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // SendAs: Settings associated with a send-as alias, which can be either the |
| // primary login address associated with the account or a custom "from" |
| // address. Send-as aliases correspond to the "Send Mail As" feature in the web |
| // interface. |
| type SendAs struct { |
| // DisplayName: A name that appears in the "From:" header for mail sent using |
| // this alias. For custom "from" addresses, when this is empty, Gmail will |
| // populate the "From:" header with the name that is used for the primary |
| // address associated with the account. If the admin has disabled the ability |
| // for users to update their name format, requests to update this field for the |
| // primary login will silently fail. |
| DisplayName string `json:"displayName,omitempty"` |
| // IsDefault: Whether this address is selected as the default "From:" address |
| // in situations such as composing a new message or sending a vacation |
| // auto-reply. Every Gmail account has exactly one default send-as address, so |
| // the only legal value that clients may write to this field is `true`. |
| // Changing this from `false` to `true` for an address will result in this |
| // field becoming `false` for the other previous default address. |
| IsDefault bool `json:"isDefault,omitempty"` |
| // IsPrimary: Whether this address is the primary address used to login to the |
| // account. Every Gmail account has exactly one primary address, and it cannot |
| // be deleted from the collection of send-as aliases. This field is read-only. |
| IsPrimary bool `json:"isPrimary,omitempty"` |
| // ReplyToAddress: An optional email address that is included in a "Reply-To:" |
| // header for mail sent using this alias. If this is empty, Gmail will not |
| // generate a "Reply-To:" header. |
| ReplyToAddress string `json:"replyToAddress,omitempty"` |
| // SendAsEmail: The email address that appears in the "From:" header for mail |
| // sent using this alias. This is read-only for all operations except create. |
| SendAsEmail string `json:"sendAsEmail,omitempty"` |
| // Signature: An optional HTML signature that is included in messages composed |
| // with this alias in the Gmail web UI. This signature is added to new emails |
| // only. |
| Signature string `json:"signature,omitempty"` |
| // SmtpMsa: An optional SMTP service that will be used as an outbound relay for |
| // mail sent using this alias. If this is empty, outbound mail will be sent |
| // directly from Gmail's servers to the destination SMTP service. This setting |
| // only applies to custom "from" aliases. |
| SmtpMsa *SmtpMsa `json:"smtpMsa,omitempty"` |
| // TreatAsAlias: Whether Gmail should treat this address as an alias for the |
| // user's primary email address. This setting only applies to custom "from" |
| // aliases. |
| TreatAsAlias bool `json:"treatAsAlias,omitempty"` |
| // VerificationStatus: Indicates whether this address has been verified for use |
| // as a send-as alias. Read-only. This setting only applies to custom "from" |
| // aliases. |
| // |
| // Possible values: |
| // "verificationStatusUnspecified" - Unspecified verification status. |
| // "accepted" - The address is ready to use as a send-as alias. |
| // "pending" - The address is awaiting verification by the owner. |
| VerificationStatus string `json:"verificationStatus,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| // ForceSendFields is a list of field names (e.g. "DisplayName") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "DisplayName") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *SendAs) MarshalJSON() ([]byte, error) { |
| type NoMethod SendAs |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // SignAndEncryptKeyPairs: The configuration of a CSE identity that uses |
| // different key pairs for signing and encryption. |
| type SignAndEncryptKeyPairs struct { |
| // EncryptionKeyPairId: The ID of the CseKeyPair that encrypts signed outgoing |
| // mail. |
| EncryptionKeyPairId string `json:"encryptionKeyPairId,omitempty"` |
| // SigningKeyPairId: The ID of the CseKeyPair that signs outgoing mail. |
| SigningKeyPairId string `json:"signingKeyPairId,omitempty"` |
| // ForceSendFields is a list of field names (e.g. "EncryptionKeyPairId") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "EncryptionKeyPairId") to include |
| // in API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *SignAndEncryptKeyPairs) MarshalJSON() ([]byte, error) { |
| type NoMethod SignAndEncryptKeyPairs |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // SmimeInfo: An S/MIME email config. |
| type SmimeInfo struct { |
| // EncryptedKeyPassword: Encrypted key password, when key is encrypted. |
| EncryptedKeyPassword string `json:"encryptedKeyPassword,omitempty"` |
| // Expiration: When the certificate expires (in milliseconds since epoch). |
| Expiration int64 `json:"expiration,omitempty,string"` |
| // Id: The immutable ID for the SmimeInfo. |
| Id string `json:"id,omitempty"` |
| // IsDefault: Whether this SmimeInfo is the default one for this user's send-as |
| // address. |
| IsDefault bool `json:"isDefault,omitempty"` |
| // IssuerCn: The S/MIME certificate issuer's common name. |
| IssuerCn string `json:"issuerCn,omitempty"` |
| // Pem: PEM formatted X509 concatenated certificate string (standard base64 |
| // encoding). Format used for returning key, which includes public key as well |
| // as certificate chain (not private key). |
| Pem string `json:"pem,omitempty"` |
| // Pkcs12: PKCS#12 format containing a single private/public key pair and |
| // certificate chain. This format is only accepted from client for creating a |
| // new SmimeInfo and is never returned, because the private key is not intended |
| // to be exported. PKCS#12 may be encrypted, in which case encryptedKeyPassword |
| // should be set appropriately. |
| Pkcs12 string `json:"pkcs12,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| // ForceSendFields is a list of field names (e.g. "EncryptedKeyPassword") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "EncryptedKeyPassword") to include |
| // in API requests with the JSON null value. By default, fields with empty |
| // values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *SmimeInfo) MarshalJSON() ([]byte, error) { |
| type NoMethod SmimeInfo |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // SmtpMsa: Configuration for communication with an SMTP service. |
| type SmtpMsa struct { |
| // Host: The hostname of the SMTP service. Required. |
| Host string `json:"host,omitempty"` |
| // Password: The password that will be used for authentication with the SMTP |
| // service. This is a write-only field that can be specified in requests to |
| // create or update SendAs settings; it is never populated in responses. |
| Password string `json:"password,omitempty"` |
| // Port: The port of the SMTP service. Required. |
| Port int64 `json:"port,omitempty"` |
| // SecurityMode: The protocol that will be used to secure communication with |
| // the SMTP service. Required. |
| // |
| // Possible values: |
| // "securityModeUnspecified" - Unspecified security mode. |
| // "none" - Communication with the remote SMTP service is unsecured. Requires |
| // port 25. |
| // "ssl" - Communication with the remote SMTP service is secured using SSL. |
| // "starttls" - Communication with the remote SMTP service is secured using |
| // STARTTLS. |
| SecurityMode string `json:"securityMode,omitempty"` |
| // Username: The username that will be used for authentication with the SMTP |
| // service. This is a write-only field that can be specified in requests to |
| // create or update SendAs settings; it is never populated in responses. |
| Username string `json:"username,omitempty"` |
| // ForceSendFields is a list of field names (e.g. "Host") to unconditionally |
| // include in API requests. By default, fields with empty or default values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "Host") to include in API requests |
| // with the JSON null value. By default, fields with empty values are omitted |
| // from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *SmtpMsa) MarshalJSON() ([]byte, error) { |
| type NoMethod SmtpMsa |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // Thread: A collection of messages representing a conversation. |
| type Thread struct { |
| // HistoryId: The ID of the last history record that modified this thread. |
| HistoryId uint64 `json:"historyId,omitempty,string"` |
| // Id: The unique ID of the thread. |
| Id string `json:"id,omitempty"` |
| // Messages: The list of messages in the thread. |
| Messages []*Message `json:"messages,omitempty"` |
| // Snippet: A short part of the message text. |
| Snippet string `json:"snippet,omitempty"` |
| |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| // ForceSendFields is a list of field names (e.g. "HistoryId") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "HistoryId") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *Thread) MarshalJSON() ([]byte, error) { |
| type NoMethod Thread |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // VacationSettings: Vacation auto-reply settings for an account. These |
| // settings correspond to the "Vacation responder" feature in the web |
| // interface. |
| type VacationSettings struct { |
| // EnableAutoReply: Flag that controls whether Gmail automatically replies to |
| // messages. |
| EnableAutoReply bool `json:"enableAutoReply,omitempty"` |
| // EndTime: An optional end time for sending auto-replies (epoch ms). When this |
| // is specified, Gmail will automatically reply only to messages that it |
| // receives before the end time. If both `startTime` and `endTime` are |
| // specified, `startTime` must precede `endTime`. |
| EndTime int64 `json:"endTime,omitempty,string"` |
| // ResponseBodyHtml: Response body in HTML format. Gmail will sanitize the HTML |
| // before storing it. If both `response_body_plain_text` and |
| // `response_body_html` are specified, `response_body_html` will be used. |
| ResponseBodyHtml string `json:"responseBodyHtml,omitempty"` |
| // ResponseBodyPlainText: Response body in plain text format. If both |
| // `response_body_plain_text` and `response_body_html` are specified, |
| // `response_body_html` will be used. |
| ResponseBodyPlainText string `json:"responseBodyPlainText,omitempty"` |
| // ResponseSubject: Optional text to prepend to the subject line in vacation |
| // responses. In order to enable auto-replies, either the response subject or |
| // the response body must be nonempty. |
| ResponseSubject string `json:"responseSubject,omitempty"` |
| // RestrictToContacts: Flag that determines whether responses are sent to |
| // recipients who are not in the user's list of contacts. |
| RestrictToContacts bool `json:"restrictToContacts,omitempty"` |
| // RestrictToDomain: Flag that determines whether responses are sent to |
| // recipients who are outside of the user's domain. This feature is only |
| // available for Google Workspace users. |
| RestrictToDomain bool `json:"restrictToDomain,omitempty"` |
| // StartTime: An optional start time for sending auto-replies (epoch ms). When |
| // this is specified, Gmail will automatically reply only to messages that it |
| // receives after the start time. If both `startTime` and `endTime` are |
| // specified, `startTime` must precede `endTime`. |
| StartTime int64 `json:"startTime,omitempty,string"` |
| |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| // ForceSendFields is a list of field names (e.g. "EnableAutoReply") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "EnableAutoReply") to include in |
| // API requests with the JSON null value. By default, fields with empty values |
| // are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *VacationSettings) MarshalJSON() ([]byte, error) { |
| type NoMethod VacationSettings |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // WatchRequest: Set up or update a new push notification watch on this user's |
| // mailbox. |
| type WatchRequest struct { |
| // LabelFilterAction: Filtering behavior of `labelIds list` specified. This |
| // field is deprecated because it caused incorrect behavior in some cases; use |
| // `label_filter_behavior` instead. |
| // |
| // Possible values: |
| // "include" - Only get push notifications for message changes relating to |
| // labelIds specified. |
| // "exclude" - Get push notifications for all message changes except those |
| // relating to labelIds specified. |
| LabelFilterAction string `json:"labelFilterAction,omitempty"` |
| // LabelFilterBehavior: Filtering behavior of `labelIds list` specified. This |
| // field replaces `label_filter_action`; if set, `label_filter_action` is |
| // ignored. |
| // |
| // Possible values: |
| // "include" - Only get push notifications for message changes relating to |
| // labelIds specified. |
| // "exclude" - Get push notifications for all message changes except those |
| // relating to labelIds specified. |
| LabelFilterBehavior string `json:"labelFilterBehavior,omitempty"` |
| // LabelIds: List of label_ids to restrict notifications about. By default, if |
| // unspecified, all changes are pushed out. If specified then dictates which |
| // labels are required for a push notification to be generated. |
| LabelIds []string `json:"labelIds,omitempty"` |
| // TopicName: A fully qualified Google Cloud Pub/Sub API topic name to publish |
| // the events to. This topic name **must** already exist in Cloud Pub/Sub and |
| // you **must** have already granted gmail "publish" permission on it. For |
| // example, "projects/my-project-identifier/topics/my-topic-name" (using the |
| // Cloud Pub/Sub "v1" topic naming format). Note that the |
| // "my-project-identifier" portion must exactly match your Google developer |
| // project id (the one executing this watch request). |
| TopicName string `json:"topicName,omitempty"` |
| // ForceSendFields is a list of field names (e.g. "LabelFilterAction") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "LabelFilterAction") to include in |
| // API requests with the JSON null value. By default, fields with empty values |
| // are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *WatchRequest) MarshalJSON() ([]byte, error) { |
| type NoMethod WatchRequest |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| // WatchResponse: Push notification watch response. |
| type WatchResponse struct { |
| // Expiration: When Gmail will stop sending notifications for mailbox updates |
| // (epoch millis). Call `watch` again before this time to renew the watch. |
| Expiration int64 `json:"expiration,omitempty,string"` |
| // HistoryId: The ID of the mailbox's current history record. |
| HistoryId uint64 `json:"historyId,omitempty,string"` |
| |
| // ServerResponse contains the HTTP response code and headers from the server. |
| googleapi.ServerResponse `json:"-"` |
| // ForceSendFields is a list of field names (e.g. "Expiration") to |
| // unconditionally include in API requests. By default, fields with empty or |
| // default values are omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-ForceSendFields for more |
| // details. |
| ForceSendFields []string `json:"-"` |
| // NullFields is a list of field names (e.g. "Expiration") to include in API |
| // requests with the JSON null value. By default, fields with empty values are |
| // omitted from API requests. See |
| // https://pkg.go.dev/google.golang.org/api#hdr-NullFields for more details. |
| NullFields []string `json:"-"` |
| } |
| |
| func (s *WatchResponse) MarshalJSON() ([]byte, error) { |
| type NoMethod WatchResponse |
| return gensupport.MarshalJSON(NoMethod(*s), s.ForceSendFields, s.NullFields) |
| } |
| |
| type UsersGetProfileCall struct { |
| s *Service |
| userId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // GetProfile: Gets the current user's Gmail profile. |
| // |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersService) GetProfile(userId string) *UsersGetProfileCall { |
| c := &UsersGetProfileCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersGetProfileCall) Fields(s ...googleapi.Field) *UsersGetProfileCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersGetProfileCall) IfNoneMatch(entityTag string) *UsersGetProfileCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersGetProfileCall) Context(ctx context.Context) *UsersGetProfileCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersGetProfileCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersGetProfileCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/profile") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.getProfile" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *Profile.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersGetProfileCall) Do(opts ...googleapi.CallOption) (*Profile, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &Profile{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersStopCall struct { |
| s *Service |
| userId string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Stop: Stop receiving push notifications for the given user mailbox. |
| // |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersService) Stop(userId string) *UsersStopCall { |
| c := &UsersStopCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersStopCall) Fields(s ...googleapi.Field) *UsersStopCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersStopCall) Context(ctx context.Context) *UsersStopCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersStopCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersStopCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/stop") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.stop" call. |
| func (c *UsersStopCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return gensupport.WrapError(err) |
| } |
| return nil |
| } |
| |
| type UsersWatchCall struct { |
| s *Service |
| userId string |
| watchrequest *WatchRequest |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Watch: Set up or update a push notification watch on the given user mailbox. |
| // |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersService) Watch(userId string, watchrequest *WatchRequest) *UsersWatchCall { |
| c := &UsersWatchCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.watchrequest = watchrequest |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersWatchCall) Fields(s ...googleapi.Field) *UsersWatchCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersWatchCall) Context(ctx context.Context) *UsersWatchCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersWatchCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersWatchCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.watchrequest) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/watch") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.watch" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *WatchResponse.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersWatchCall) Do(opts ...googleapi.CallOption) (*WatchResponse, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &WatchResponse{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersDraftsCreateCall struct { |
| s *Service |
| userId string |
| draft *Draft |
| urlParams_ gensupport.URLParams |
| mediaInfo_ *gensupport.MediaInfo |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Create: Creates a new draft with the `DRAFT` label. |
| // |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersDraftsService) Create(userId string, draft *Draft) *UsersDraftsCreateCall { |
| c := &UsersDraftsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.draft = draft |
| return c |
| } |
| |
| // Media specifies the media to upload in one or more chunks. The chunk size |
| // may be controlled by supplying a MediaOption generated by |
| // googleapi.ChunkSize. The chunk size defaults to |
| // googleapi.DefaultUploadChunkSize.The Content-Type header used in the upload |
| // request will be determined by sniffing the contents of r, unless a |
| // MediaOption generated by googleapi.ContentType is supplied. |
| // At most one of Media and ResumableMedia may be set. |
| func (c *UsersDraftsCreateCall) Media(r io.Reader, options ...googleapi.MediaOption) *UsersDraftsCreateCall { |
| c.mediaInfo_ = gensupport.NewInfoFromMedia(r, options) |
| return c |
| } |
| |
| // ResumableMedia specifies the media to upload in chunks and can be canceled |
| // with ctx. |
| // |
| // Deprecated: use Media instead. |
| // |
| // At most one of Media and ResumableMedia may be set. mediaType identifies the |
| // MIME media type of the upload, such as "image/png". If mediaType is "", it |
| // will be auto-detected. The provided ctx will supersede any context |
| // previously provided to the Context method. |
| func (c *UsersDraftsCreateCall) ResumableMedia(ctx context.Context, r io.ReaderAt, size int64, mediaType string) *UsersDraftsCreateCall { |
| c.ctx_ = ctx |
| c.mediaInfo_ = gensupport.NewInfoFromResumableMedia(r, size, mediaType) |
| return c |
| } |
| |
| // ProgressUpdater provides a callback function that will be called after every |
| // chunk. It should be a low-latency function in order to not slow down the |
| // upload operation. This should only be called when using ResumableMedia (as |
| // opposed to Media). |
| func (c *UsersDraftsCreateCall) ProgressUpdater(pu googleapi.ProgressUpdater) *UsersDraftsCreateCall { |
| c.mediaInfo_.SetProgressUpdater(pu) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersDraftsCreateCall) Fields(s ...googleapi.Field) *UsersDraftsCreateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| // This context will supersede any context previously provided to the |
| // ResumableMedia method. |
| func (c *UsersDraftsCreateCall) Context(ctx context.Context) *UsersDraftsCreateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersDraftsCreateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersDraftsCreateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.draft) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/drafts") |
| if c.mediaInfo_ != nil { |
| urls = googleapi.ResolveRelative(c.s.BasePath, "/upload/gmail/v1/users/{userId}/drafts") |
| c.urlParams_.Set("uploadType", c.mediaInfo_.UploadType()) |
| } |
| if body == nil { |
| body = new(bytes.Buffer) |
| reqHeaders.Set("Content-Type", "application/json") |
| } |
| body, getBody, cleanup := c.mediaInfo_.UploadRequest(reqHeaders, body) |
| defer cleanup() |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| req.GetBody = getBody |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.drafts.create" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *Draft.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersDraftsCreateCall) Do(opts ...googleapi.CallOption) (*Draft, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| rx := c.mediaInfo_.ResumableUpload(res.Header.Get("Location")) |
| if rx != nil { |
| rx.Client = c.s.client |
| rx.UserAgent = c.s.userAgent() |
| ctx := c.ctx_ |
| if ctx == nil { |
| ctx = context.TODO() |
| } |
| res, err = rx.Upload(ctx) |
| if err != nil { |
| return nil, err |
| } |
| defer res.Body.Close() |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| } |
| ret := &Draft{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersDraftsDeleteCall struct { |
| s *Service |
| userId string |
| id string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Immediately and permanently deletes the specified draft. Does not |
| // simply trash it. |
| // |
| // - id: The ID of the draft to delete. |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersDraftsService) Delete(userId string, id string) *UsersDraftsDeleteCall { |
| c := &UsersDraftsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.id = id |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersDraftsDeleteCall) Fields(s ...googleapi.Field) *UsersDraftsDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersDraftsDeleteCall) Context(ctx context.Context) *UsersDraftsDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersDraftsDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersDraftsDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/drafts/{id}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("DELETE", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "id": c.id, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.drafts.delete" call. |
| func (c *UsersDraftsDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return gensupport.WrapError(err) |
| } |
| return nil |
| } |
| |
| type UsersDraftsGetCall struct { |
| s *Service |
| userId string |
| id string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Gets the specified draft. |
| // |
| // - id: The ID of the draft to retrieve. |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersDraftsService) Get(userId string, id string) *UsersDraftsGetCall { |
| c := &UsersDraftsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.id = id |
| return c |
| } |
| |
| // Format sets the optional parameter "format": The format to return the draft |
| // in. |
| // |
| // Possible values: |
| // |
| // "minimal" - Returns only email message ID and labels; does not return the |
| // |
| // email headers, body, or payload. |
| // |
| // "full" (default) - Returns the full email message data with body content |
| // |
| // parsed in the `payload` field; the `raw` field is not used. Format cannot be |
| // used when accessing the api using the gmail.metadata scope. |
| // |
| // "raw" - Returns the full email message data with body content in the `raw` |
| // |
| // field as a base64url encoded string; the `payload` field is not used. Format |
| // cannot be used when accessing the api using the gmail.metadata scope. |
| // |
| // "metadata" - Returns only email message ID, labels, and email headers. |
| func (c *UsersDraftsGetCall) Format(format string) *UsersDraftsGetCall { |
| c.urlParams_.Set("format", format) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersDraftsGetCall) Fields(s ...googleapi.Field) *UsersDraftsGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersDraftsGetCall) IfNoneMatch(entityTag string) *UsersDraftsGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersDraftsGetCall) Context(ctx context.Context) *UsersDraftsGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersDraftsGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersDraftsGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/drafts/{id}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "id": c.id, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.drafts.get" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *Draft.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersDraftsGetCall) Do(opts ...googleapi.CallOption) (*Draft, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &Draft{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersDraftsListCall struct { |
| s *Service |
| userId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Lists the drafts in the user's mailbox. |
| // |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersDraftsService) List(userId string) *UsersDraftsListCall { |
| c := &UsersDraftsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| return c |
| } |
| |
| // IncludeSpamTrash sets the optional parameter "includeSpamTrash": Include |
| // drafts from `SPAM` and `TRASH` in the results. |
| func (c *UsersDraftsListCall) IncludeSpamTrash(includeSpamTrash bool) *UsersDraftsListCall { |
| c.urlParams_.Set("includeSpamTrash", fmt.Sprint(includeSpamTrash)) |
| return c |
| } |
| |
| // MaxResults sets the optional parameter "maxResults": Maximum number of |
| // drafts to return. This field defaults to 100. The maximum allowed value for |
| // this field is 500. |
| func (c *UsersDraftsListCall) MaxResults(maxResults int64) *UsersDraftsListCall { |
| c.urlParams_.Set("maxResults", fmt.Sprint(maxResults)) |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": Page token to retrieve a |
| // specific page of results in the list. |
| func (c *UsersDraftsListCall) PageToken(pageToken string) *UsersDraftsListCall { |
| c.urlParams_.Set("pageToken", pageToken) |
| return c |
| } |
| |
| // Q sets the optional parameter "q": Only return draft messages matching the |
| // specified query. Supports the same query format as the Gmail search box. For |
| // example, "from:someuser@example.com rfc822msgid: is:unread". |
| func (c *UsersDraftsListCall) Q(q string) *UsersDraftsListCall { |
| c.urlParams_.Set("q", q) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersDraftsListCall) Fields(s ...googleapi.Field) *UsersDraftsListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersDraftsListCall) IfNoneMatch(entityTag string) *UsersDraftsListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersDraftsListCall) Context(ctx context.Context) *UsersDraftsListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersDraftsListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersDraftsListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/drafts") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.drafts.list" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *ListDraftsResponse.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified was |
| // returned. |
| func (c *UsersDraftsListCall) Do(opts ...googleapi.CallOption) (*ListDraftsResponse, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &ListDraftsResponse{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| // Pages invokes f for each page of results. |
| // A non-nil error returned from f will halt the iteration. |
| // The provided context supersedes any context provided to the Context method. |
| func (c *UsersDraftsListCall) Pages(ctx context.Context, f func(*ListDraftsResponse) error) error { |
| c.ctx_ = ctx |
| defer c.PageToken(c.urlParams_.Get("pageToken")) |
| for { |
| x, err := c.Do() |
| if err != nil { |
| return err |
| } |
| if err := f(x); err != nil { |
| return err |
| } |
| if x.NextPageToken == "" { |
| return nil |
| } |
| c.PageToken(x.NextPageToken) |
| } |
| } |
| |
| type UsersDraftsSendCall struct { |
| s *Service |
| userId string |
| draft *Draft |
| urlParams_ gensupport.URLParams |
| mediaInfo_ *gensupport.MediaInfo |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Send: Sends the specified, existing draft to the recipients in the `To`, |
| // `Cc`, and `Bcc` headers. |
| // |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersDraftsService) Send(userId string, draft *Draft) *UsersDraftsSendCall { |
| c := &UsersDraftsSendCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.draft = draft |
| return c |
| } |
| |
| // Media specifies the media to upload in one or more chunks. The chunk size |
| // may be controlled by supplying a MediaOption generated by |
| // googleapi.ChunkSize. The chunk size defaults to |
| // googleapi.DefaultUploadChunkSize.The Content-Type header used in the upload |
| // request will be determined by sniffing the contents of r, unless a |
| // MediaOption generated by googleapi.ContentType is supplied. |
| // At most one of Media and ResumableMedia may be set. |
| func (c *UsersDraftsSendCall) Media(r io.Reader, options ...googleapi.MediaOption) *UsersDraftsSendCall { |
| c.mediaInfo_ = gensupport.NewInfoFromMedia(r, options) |
| return c |
| } |
| |
| // ResumableMedia specifies the media to upload in chunks and can be canceled |
| // with ctx. |
| // |
| // Deprecated: use Media instead. |
| // |
| // At most one of Media and ResumableMedia may be set. mediaType identifies the |
| // MIME media type of the upload, such as "image/png". If mediaType is "", it |
| // will be auto-detected. The provided ctx will supersede any context |
| // previously provided to the Context method. |
| func (c *UsersDraftsSendCall) ResumableMedia(ctx context.Context, r io.ReaderAt, size int64, mediaType string) *UsersDraftsSendCall { |
| c.ctx_ = ctx |
| c.mediaInfo_ = gensupport.NewInfoFromResumableMedia(r, size, mediaType) |
| return c |
| } |
| |
| // ProgressUpdater provides a callback function that will be called after every |
| // chunk. It should be a low-latency function in order to not slow down the |
| // upload operation. This should only be called when using ResumableMedia (as |
| // opposed to Media). |
| func (c *UsersDraftsSendCall) ProgressUpdater(pu googleapi.ProgressUpdater) *UsersDraftsSendCall { |
| c.mediaInfo_.SetProgressUpdater(pu) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersDraftsSendCall) Fields(s ...googleapi.Field) *UsersDraftsSendCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| // This context will supersede any context previously provided to the |
| // ResumableMedia method. |
| func (c *UsersDraftsSendCall) Context(ctx context.Context) *UsersDraftsSendCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersDraftsSendCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersDraftsSendCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.draft) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/drafts/send") |
| if c.mediaInfo_ != nil { |
| urls = googleapi.ResolveRelative(c.s.BasePath, "/upload/gmail/v1/users/{userId}/drafts/send") |
| c.urlParams_.Set("uploadType", c.mediaInfo_.UploadType()) |
| } |
| if body == nil { |
| body = new(bytes.Buffer) |
| reqHeaders.Set("Content-Type", "application/json") |
| } |
| body, getBody, cleanup := c.mediaInfo_.UploadRequest(reqHeaders, body) |
| defer cleanup() |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| req.GetBody = getBody |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.drafts.send" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *Message.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersDraftsSendCall) Do(opts ...googleapi.CallOption) (*Message, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| rx := c.mediaInfo_.ResumableUpload(res.Header.Get("Location")) |
| if rx != nil { |
| rx.Client = c.s.client |
| rx.UserAgent = c.s.userAgent() |
| ctx := c.ctx_ |
| if ctx == nil { |
| ctx = context.TODO() |
| } |
| res, err = rx.Upload(ctx) |
| if err != nil { |
| return nil, err |
| } |
| defer res.Body.Close() |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| } |
| ret := &Message{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersDraftsUpdateCall struct { |
| s *Service |
| userId string |
| id string |
| draft *Draft |
| urlParams_ gensupport.URLParams |
| mediaInfo_ *gensupport.MediaInfo |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Update: Replaces a draft's content. |
| // |
| // - id: The ID of the draft to update. |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersDraftsService) Update(userId string, id string, draft *Draft) *UsersDraftsUpdateCall { |
| c := &UsersDraftsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.id = id |
| c.draft = draft |
| return c |
| } |
| |
| // Media specifies the media to upload in one or more chunks. The chunk size |
| // may be controlled by supplying a MediaOption generated by |
| // googleapi.ChunkSize. The chunk size defaults to |
| // googleapi.DefaultUploadChunkSize.The Content-Type header used in the upload |
| // request will be determined by sniffing the contents of r, unless a |
| // MediaOption generated by googleapi.ContentType is supplied. |
| // At most one of Media and ResumableMedia may be set. |
| func (c *UsersDraftsUpdateCall) Media(r io.Reader, options ...googleapi.MediaOption) *UsersDraftsUpdateCall { |
| c.mediaInfo_ = gensupport.NewInfoFromMedia(r, options) |
| return c |
| } |
| |
| // ResumableMedia specifies the media to upload in chunks and can be canceled |
| // with ctx. |
| // |
| // Deprecated: use Media instead. |
| // |
| // At most one of Media and ResumableMedia may be set. mediaType identifies the |
| // MIME media type of the upload, such as "image/png". If mediaType is "", it |
| // will be auto-detected. The provided ctx will supersede any context |
| // previously provided to the Context method. |
| func (c *UsersDraftsUpdateCall) ResumableMedia(ctx context.Context, r io.ReaderAt, size int64, mediaType string) *UsersDraftsUpdateCall { |
| c.ctx_ = ctx |
| c.mediaInfo_ = gensupport.NewInfoFromResumableMedia(r, size, mediaType) |
| return c |
| } |
| |
| // ProgressUpdater provides a callback function that will be called after every |
| // chunk. It should be a low-latency function in order to not slow down the |
| // upload operation. This should only be called when using ResumableMedia (as |
| // opposed to Media). |
| func (c *UsersDraftsUpdateCall) ProgressUpdater(pu googleapi.ProgressUpdater) *UsersDraftsUpdateCall { |
| c.mediaInfo_.SetProgressUpdater(pu) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersDraftsUpdateCall) Fields(s ...googleapi.Field) *UsersDraftsUpdateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| // This context will supersede any context previously provided to the |
| // ResumableMedia method. |
| func (c *UsersDraftsUpdateCall) Context(ctx context.Context) *UsersDraftsUpdateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersDraftsUpdateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersDraftsUpdateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.draft) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/drafts/{id}") |
| if c.mediaInfo_ != nil { |
| urls = googleapi.ResolveRelative(c.s.BasePath, "/upload/gmail/v1/users/{userId}/drafts/{id}") |
| c.urlParams_.Set("uploadType", c.mediaInfo_.UploadType()) |
| } |
| if body == nil { |
| body = new(bytes.Buffer) |
| reqHeaders.Set("Content-Type", "application/json") |
| } |
| body, getBody, cleanup := c.mediaInfo_.UploadRequest(reqHeaders, body) |
| defer cleanup() |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("PUT", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| req.GetBody = getBody |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "id": c.id, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.drafts.update" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *Draft.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersDraftsUpdateCall) Do(opts ...googleapi.CallOption) (*Draft, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| rx := c.mediaInfo_.ResumableUpload(res.Header.Get("Location")) |
| if rx != nil { |
| rx.Client = c.s.client |
| rx.UserAgent = c.s.userAgent() |
| ctx := c.ctx_ |
| if ctx == nil { |
| ctx = context.TODO() |
| } |
| res, err = rx.Upload(ctx) |
| if err != nil { |
| return nil, err |
| } |
| defer res.Body.Close() |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| } |
| ret := &Draft{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersHistoryListCall struct { |
| s *Service |
| userId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Lists the history of all changes to the given mailbox. History results |
| // are returned in chronological order (increasing `historyId`). |
| // |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersHistoryService) List(userId string) *UsersHistoryListCall { |
| c := &UsersHistoryListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| return c |
| } |
| |
| // HistoryTypes sets the optional parameter "historyTypes": History types to be |
| // returned by the function |
| // |
| // Possible values: |
| // |
| // "messageAdded" |
| // "messageDeleted" |
| // "labelAdded" |
| // "labelRemoved" |
| func (c *UsersHistoryListCall) HistoryTypes(historyTypes ...string) *UsersHistoryListCall { |
| c.urlParams_.SetMulti("historyTypes", append([]string{}, historyTypes...)) |
| return c |
| } |
| |
| // LabelId sets the optional parameter "labelId": Only return messages with a |
| // label matching the ID. |
| func (c *UsersHistoryListCall) LabelId(labelId string) *UsersHistoryListCall { |
| c.urlParams_.Set("labelId", labelId) |
| return c |
| } |
| |
| // MaxResults sets the optional parameter "maxResults": Maximum number of |
| // history records to return. This field defaults to 100. The maximum allowed |
| // value for this field is 500. |
| func (c *UsersHistoryListCall) MaxResults(maxResults int64) *UsersHistoryListCall { |
| c.urlParams_.Set("maxResults", fmt.Sprint(maxResults)) |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": Page token to retrieve a |
| // specific page of results in the list. |
| func (c *UsersHistoryListCall) PageToken(pageToken string) *UsersHistoryListCall { |
| c.urlParams_.Set("pageToken", pageToken) |
| return c |
| } |
| |
| // StartHistoryId sets the optional parameter "startHistoryId": Required. |
| // Returns history records after the specified `startHistoryId`. The supplied |
| // `startHistoryId` should be obtained from the `historyId` of a message, |
| // thread, or previous `list` response. History IDs increase chronologically |
| // but are not contiguous with random gaps in between valid IDs. Supplying an |
| // invalid or out of date `startHistoryId` typically returns an `HTTP 404` |
| // error code. A `historyId` is typically valid for at least a week, but in |
| // some rare circumstances may be valid for only a few hours. If you receive an |
| // `HTTP 404` error response, your application should perform a full sync. If |
| // you receive no `nextPageToken` in the response, there are no updates to |
| // retrieve and you can store the returned `historyId` for a future request. |
| func (c *UsersHistoryListCall) StartHistoryId(startHistoryId uint64) *UsersHistoryListCall { |
| c.urlParams_.Set("startHistoryId", fmt.Sprint(startHistoryId)) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersHistoryListCall) Fields(s ...googleapi.Field) *UsersHistoryListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersHistoryListCall) IfNoneMatch(entityTag string) *UsersHistoryListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersHistoryListCall) Context(ctx context.Context) *UsersHistoryListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersHistoryListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersHistoryListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/history") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.history.list" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *ListHistoryResponse.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified was |
| // returned. |
| func (c *UsersHistoryListCall) Do(opts ...googleapi.CallOption) (*ListHistoryResponse, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &ListHistoryResponse{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| // Pages invokes f for each page of results. |
| // A non-nil error returned from f will halt the iteration. |
| // The provided context supersedes any context provided to the Context method. |
| func (c *UsersHistoryListCall) Pages(ctx context.Context, f func(*ListHistoryResponse) error) error { |
| c.ctx_ = ctx |
| defer c.PageToken(c.urlParams_.Get("pageToken")) |
| for { |
| x, err := c.Do() |
| if err != nil { |
| return err |
| } |
| if err := f(x); err != nil { |
| return err |
| } |
| if x.NextPageToken == "" { |
| return nil |
| } |
| c.PageToken(x.NextPageToken) |
| } |
| } |
| |
| type UsersLabelsCreateCall struct { |
| s *Service |
| userId string |
| label *Label |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Create: Creates a new label. |
| // |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersLabelsService) Create(userId string, label *Label) *UsersLabelsCreateCall { |
| c := &UsersLabelsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.label = label |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersLabelsCreateCall) Fields(s ...googleapi.Field) *UsersLabelsCreateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersLabelsCreateCall) Context(ctx context.Context) *UsersLabelsCreateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersLabelsCreateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersLabelsCreateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.label) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/labels") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.labels.create" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *Label.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersLabelsCreateCall) Do(opts ...googleapi.CallOption) (*Label, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &Label{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersLabelsDeleteCall struct { |
| s *Service |
| userId string |
| id string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Immediately and permanently deletes the specified label and removes |
| // it from any messages and threads that it is applied to. |
| // |
| // - id: The ID of the label to delete. |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersLabelsService) Delete(userId string, id string) *UsersLabelsDeleteCall { |
| c := &UsersLabelsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.id = id |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersLabelsDeleteCall) Fields(s ...googleapi.Field) *UsersLabelsDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersLabelsDeleteCall) Context(ctx context.Context) *UsersLabelsDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersLabelsDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersLabelsDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/labels/{id}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("DELETE", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "id": c.id, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.labels.delete" call. |
| func (c *UsersLabelsDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return gensupport.WrapError(err) |
| } |
| return nil |
| } |
| |
| type UsersLabelsGetCall struct { |
| s *Service |
| userId string |
| id string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Gets the specified label. |
| // |
| // - id: The ID of the label to retrieve. |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersLabelsService) Get(userId string, id string) *UsersLabelsGetCall { |
| c := &UsersLabelsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.id = id |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersLabelsGetCall) Fields(s ...googleapi.Field) *UsersLabelsGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersLabelsGetCall) IfNoneMatch(entityTag string) *UsersLabelsGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersLabelsGetCall) Context(ctx context.Context) *UsersLabelsGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersLabelsGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersLabelsGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/labels/{id}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "id": c.id, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.labels.get" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *Label.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersLabelsGetCall) Do(opts ...googleapi.CallOption) (*Label, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &Label{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersLabelsListCall struct { |
| s *Service |
| userId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Lists all labels in the user's mailbox. |
| // |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersLabelsService) List(userId string) *UsersLabelsListCall { |
| c := &UsersLabelsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersLabelsListCall) Fields(s ...googleapi.Field) *UsersLabelsListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersLabelsListCall) IfNoneMatch(entityTag string) *UsersLabelsListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersLabelsListCall) Context(ctx context.Context) *UsersLabelsListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersLabelsListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersLabelsListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/labels") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.labels.list" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *ListLabelsResponse.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified was |
| // returned. |
| func (c *UsersLabelsListCall) Do(opts ...googleapi.CallOption) (*ListLabelsResponse, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &ListLabelsResponse{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersLabelsPatchCall struct { |
| s *Service |
| userId string |
| id string |
| label *Label |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Patch: Patch the specified label. |
| // |
| // - id: The ID of the label to update. |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersLabelsService) Patch(userId string, id string, label *Label) *UsersLabelsPatchCall { |
| c := &UsersLabelsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.id = id |
| c.label = label |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersLabelsPatchCall) Fields(s ...googleapi.Field) *UsersLabelsPatchCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersLabelsPatchCall) Context(ctx context.Context) *UsersLabelsPatchCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersLabelsPatchCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersLabelsPatchCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.label) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/labels/{id}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("PATCH", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "id": c.id, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.labels.patch" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *Label.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersLabelsPatchCall) Do(opts ...googleapi.CallOption) (*Label, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &Label{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersLabelsUpdateCall struct { |
| s *Service |
| userId string |
| id string |
| label *Label |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Update: Updates the specified label. |
| // |
| // - id: The ID of the label to update. |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersLabelsService) Update(userId string, id string, label *Label) *UsersLabelsUpdateCall { |
| c := &UsersLabelsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.id = id |
| c.label = label |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersLabelsUpdateCall) Fields(s ...googleapi.Field) *UsersLabelsUpdateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersLabelsUpdateCall) Context(ctx context.Context) *UsersLabelsUpdateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersLabelsUpdateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersLabelsUpdateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.label) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/labels/{id}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("PUT", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "id": c.id, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.labels.update" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *Label.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersLabelsUpdateCall) Do(opts ...googleapi.CallOption) (*Label, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &Label{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersMessagesBatchDeleteCall struct { |
| s *Service |
| userId string |
| batchdeletemessagesrequest *BatchDeleteMessagesRequest |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // BatchDelete: Deletes many messages by message ID. Provides no guarantees |
| // that messages were not already deleted or even existed at all. |
| // |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersMessagesService) BatchDelete(userId string, batchdeletemessagesrequest *BatchDeleteMessagesRequest) *UsersMessagesBatchDeleteCall { |
| c := &UsersMessagesBatchDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.batchdeletemessagesrequest = batchdeletemessagesrequest |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersMessagesBatchDeleteCall) Fields(s ...googleapi.Field) *UsersMessagesBatchDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersMessagesBatchDeleteCall) Context(ctx context.Context) *UsersMessagesBatchDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersMessagesBatchDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersMessagesBatchDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.batchdeletemessagesrequest) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/messages/batchDelete") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.messages.batchDelete" call. |
| func (c *UsersMessagesBatchDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return gensupport.WrapError(err) |
| } |
| return nil |
| } |
| |
| type UsersMessagesBatchModifyCall struct { |
| s *Service |
| userId string |
| batchmodifymessagesrequest *BatchModifyMessagesRequest |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // BatchModify: Modifies the labels on the specified messages. |
| // |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersMessagesService) BatchModify(userId string, batchmodifymessagesrequest *BatchModifyMessagesRequest) *UsersMessagesBatchModifyCall { |
| c := &UsersMessagesBatchModifyCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.batchmodifymessagesrequest = batchmodifymessagesrequest |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersMessagesBatchModifyCall) Fields(s ...googleapi.Field) *UsersMessagesBatchModifyCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersMessagesBatchModifyCall) Context(ctx context.Context) *UsersMessagesBatchModifyCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersMessagesBatchModifyCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersMessagesBatchModifyCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.batchmodifymessagesrequest) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/messages/batchModify") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.messages.batchModify" call. |
| func (c *UsersMessagesBatchModifyCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return gensupport.WrapError(err) |
| } |
| return nil |
| } |
| |
| type UsersMessagesDeleteCall struct { |
| s *Service |
| userId string |
| id string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Immediately and permanently deletes the specified message. This |
| // operation cannot be undone. Prefer `messages.trash` instead. |
| // |
| // - id: The ID of the message to delete. |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersMessagesService) Delete(userId string, id string) *UsersMessagesDeleteCall { |
| c := &UsersMessagesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.id = id |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersMessagesDeleteCall) Fields(s ...googleapi.Field) *UsersMessagesDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersMessagesDeleteCall) Context(ctx context.Context) *UsersMessagesDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersMessagesDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersMessagesDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/messages/{id}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("DELETE", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "id": c.id, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.messages.delete" call. |
| func (c *UsersMessagesDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return gensupport.WrapError(err) |
| } |
| return nil |
| } |
| |
| type UsersMessagesGetCall struct { |
| s *Service |
| userId string |
| id string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Gets the specified message. |
| // |
| // - id: The ID of the message to retrieve. This ID is usually retrieved using |
| // `messages.list`. The ID is also contained in the result when a message is |
| // inserted (`messages.insert`) or imported (`messages.import`). |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersMessagesService) Get(userId string, id string) *UsersMessagesGetCall { |
| c := &UsersMessagesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.id = id |
| return c |
| } |
| |
| // Format sets the optional parameter "format": The format to return the |
| // message in. |
| // |
| // Possible values: |
| // |
| // "minimal" - Returns only email message ID and labels; does not return the |
| // |
| // email headers, body, or payload. |
| // |
| // "full" (default) - Returns the full email message data with body content |
| // |
| // parsed in the `payload` field; the `raw` field is not used. Format cannot be |
| // used when accessing the api using the gmail.metadata scope. |
| // |
| // "raw" - Returns the full email message data with body content in the `raw` |
| // |
| // field as a base64url encoded string; the `payload` field is not used. Format |
| // cannot be used when accessing the api using the gmail.metadata scope. |
| // |
| // "metadata" - Returns only email message ID, labels, and email headers. |
| func (c *UsersMessagesGetCall) Format(format string) *UsersMessagesGetCall { |
| c.urlParams_.Set("format", format) |
| return c |
| } |
| |
| // MetadataHeaders sets the optional parameter "metadataHeaders": When given |
| // and format is `METADATA`, only include headers specified. |
| func (c *UsersMessagesGetCall) MetadataHeaders(metadataHeaders ...string) *UsersMessagesGetCall { |
| c.urlParams_.SetMulti("metadataHeaders", append([]string{}, metadataHeaders...)) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersMessagesGetCall) Fields(s ...googleapi.Field) *UsersMessagesGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersMessagesGetCall) IfNoneMatch(entityTag string) *UsersMessagesGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersMessagesGetCall) Context(ctx context.Context) *UsersMessagesGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersMessagesGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersMessagesGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/messages/{id}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "id": c.id, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.messages.get" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *Message.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersMessagesGetCall) Do(opts ...googleapi.CallOption) (*Message, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &Message{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersMessagesImportCall struct { |
| s *Service |
| userId string |
| message *Message |
| urlParams_ gensupport.URLParams |
| mediaInfo_ *gensupport.MediaInfo |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Import: Imports a message into only this user's mailbox, with standard email |
| // delivery scanning and classification similar to receiving via SMTP. This |
| // method doesn't perform SPF checks, so it might not work for some spam |
| // messages, such as those attempting to perform domain spoofing. This method |
| // does not send a message. |
| // |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersMessagesService) Import(userId string, message *Message) *UsersMessagesImportCall { |
| c := &UsersMessagesImportCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.message = message |
| return c |
| } |
| |
| // Deleted sets the optional parameter "deleted": Mark the email as permanently |
| // deleted (not TRASH) and only visible in Google Vault to a Vault |
| // administrator. Only used for Google Workspace accounts. |
| func (c *UsersMessagesImportCall) Deleted(deleted bool) *UsersMessagesImportCall { |
| c.urlParams_.Set("deleted", fmt.Sprint(deleted)) |
| return c |
| } |
| |
| // InternalDateSource sets the optional parameter "internalDateSource": Source |
| // for Gmail's internal date of the message. |
| // |
| // Possible values: |
| // |
| // "receivedTime" - Internal message date set to current time when received |
| // |
| // by Gmail. |
| // |
| // "dateHeader" (default) - Internal message time based on 'Date' header in |
| // |
| // email, when valid. |
| func (c *UsersMessagesImportCall) InternalDateSource(internalDateSource string) *UsersMessagesImportCall { |
| c.urlParams_.Set("internalDateSource", internalDateSource) |
| return c |
| } |
| |
| // NeverMarkSpam sets the optional parameter "neverMarkSpam": Ignore the Gmail |
| // spam classifier decision and never mark this email as SPAM in the mailbox. |
| func (c *UsersMessagesImportCall) NeverMarkSpam(neverMarkSpam bool) *UsersMessagesImportCall { |
| c.urlParams_.Set("neverMarkSpam", fmt.Sprint(neverMarkSpam)) |
| return c |
| } |
| |
| // ProcessForCalendar sets the optional parameter "processForCalendar": Process |
| // calendar invites in the email and add any extracted meetings to the Google |
| // Calendar for this user. |
| func (c *UsersMessagesImportCall) ProcessForCalendar(processForCalendar bool) *UsersMessagesImportCall { |
| c.urlParams_.Set("processForCalendar", fmt.Sprint(processForCalendar)) |
| return c |
| } |
| |
| // Media specifies the media to upload in one or more chunks. The chunk size |
| // may be controlled by supplying a MediaOption generated by |
| // googleapi.ChunkSize. The chunk size defaults to |
| // googleapi.DefaultUploadChunkSize.The Content-Type header used in the upload |
| // request will be determined by sniffing the contents of r, unless a |
| // MediaOption generated by googleapi.ContentType is supplied. |
| // At most one of Media and ResumableMedia may be set. |
| func (c *UsersMessagesImportCall) Media(r io.Reader, options ...googleapi.MediaOption) *UsersMessagesImportCall { |
| c.mediaInfo_ = gensupport.NewInfoFromMedia(r, options) |
| return c |
| } |
| |
| // ResumableMedia specifies the media to upload in chunks and can be canceled |
| // with ctx. |
| // |
| // Deprecated: use Media instead. |
| // |
| // At most one of Media and ResumableMedia may be set. mediaType identifies the |
| // MIME media type of the upload, such as "image/png". If mediaType is "", it |
| // will be auto-detected. The provided ctx will supersede any context |
| // previously provided to the Context method. |
| func (c *UsersMessagesImportCall) ResumableMedia(ctx context.Context, r io.ReaderAt, size int64, mediaType string) *UsersMessagesImportCall { |
| c.ctx_ = ctx |
| c.mediaInfo_ = gensupport.NewInfoFromResumableMedia(r, size, mediaType) |
| return c |
| } |
| |
| // ProgressUpdater provides a callback function that will be called after every |
| // chunk. It should be a low-latency function in order to not slow down the |
| // upload operation. This should only be called when using ResumableMedia (as |
| // opposed to Media). |
| func (c *UsersMessagesImportCall) ProgressUpdater(pu googleapi.ProgressUpdater) *UsersMessagesImportCall { |
| c.mediaInfo_.SetProgressUpdater(pu) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersMessagesImportCall) Fields(s ...googleapi.Field) *UsersMessagesImportCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| // This context will supersede any context previously provided to the |
| // ResumableMedia method. |
| func (c *UsersMessagesImportCall) Context(ctx context.Context) *UsersMessagesImportCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersMessagesImportCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersMessagesImportCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.message) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/messages/import") |
| if c.mediaInfo_ != nil { |
| urls = googleapi.ResolveRelative(c.s.BasePath, "/upload/gmail/v1/users/{userId}/messages/import") |
| c.urlParams_.Set("uploadType", c.mediaInfo_.UploadType()) |
| } |
| if body == nil { |
| body = new(bytes.Buffer) |
| reqHeaders.Set("Content-Type", "application/json") |
| } |
| body, getBody, cleanup := c.mediaInfo_.UploadRequest(reqHeaders, body) |
| defer cleanup() |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| req.GetBody = getBody |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.messages.import" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *Message.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersMessagesImportCall) Do(opts ...googleapi.CallOption) (*Message, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| rx := c.mediaInfo_.ResumableUpload(res.Header.Get("Location")) |
| if rx != nil { |
| rx.Client = c.s.client |
| rx.UserAgent = c.s.userAgent() |
| ctx := c.ctx_ |
| if ctx == nil { |
| ctx = context.TODO() |
| } |
| res, err = rx.Upload(ctx) |
| if err != nil { |
| return nil, err |
| } |
| defer res.Body.Close() |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| } |
| ret := &Message{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersMessagesInsertCall struct { |
| s *Service |
| userId string |
| message *Message |
| urlParams_ gensupport.URLParams |
| mediaInfo_ *gensupport.MediaInfo |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Insert: Directly inserts a message into only this user's mailbox similar to |
| // `IMAP APPEND`, bypassing most scanning and classification. Does not send a |
| // message. |
| // |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersMessagesService) Insert(userId string, message *Message) *UsersMessagesInsertCall { |
| c := &UsersMessagesInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.message = message |
| return c |
| } |
| |
| // Deleted sets the optional parameter "deleted": Mark the email as permanently |
| // deleted (not TRASH) and only visible in Google Vault to a Vault |
| // administrator. Only used for Google Workspace accounts. |
| func (c *UsersMessagesInsertCall) Deleted(deleted bool) *UsersMessagesInsertCall { |
| c.urlParams_.Set("deleted", fmt.Sprint(deleted)) |
| return c |
| } |
| |
| // InternalDateSource sets the optional parameter "internalDateSource": Source |
| // for Gmail's internal date of the message. |
| // |
| // Possible values: |
| // |
| // "receivedTime" (default) - Internal message date set to current time when |
| // |
| // received by Gmail. |
| // |
| // "dateHeader" - Internal message time based on 'Date' header in email, when |
| // |
| // valid. |
| func (c *UsersMessagesInsertCall) InternalDateSource(internalDateSource string) *UsersMessagesInsertCall { |
| c.urlParams_.Set("internalDateSource", internalDateSource) |
| return c |
| } |
| |
| // Media specifies the media to upload in one or more chunks. The chunk size |
| // may be controlled by supplying a MediaOption generated by |
| // googleapi.ChunkSize. The chunk size defaults to |
| // googleapi.DefaultUploadChunkSize.The Content-Type header used in the upload |
| // request will be determined by sniffing the contents of r, unless a |
| // MediaOption generated by googleapi.ContentType is supplied. |
| // At most one of Media and ResumableMedia may be set. |
| func (c *UsersMessagesInsertCall) Media(r io.Reader, options ...googleapi.MediaOption) *UsersMessagesInsertCall { |
| c.mediaInfo_ = gensupport.NewInfoFromMedia(r, options) |
| return c |
| } |
| |
| // ResumableMedia specifies the media to upload in chunks and can be canceled |
| // with ctx. |
| // |
| // Deprecated: use Media instead. |
| // |
| // At most one of Media and ResumableMedia may be set. mediaType identifies the |
| // MIME media type of the upload, such as "image/png". If mediaType is "", it |
| // will be auto-detected. The provided ctx will supersede any context |
| // previously provided to the Context method. |
| func (c *UsersMessagesInsertCall) ResumableMedia(ctx context.Context, r io.ReaderAt, size int64, mediaType string) *UsersMessagesInsertCall { |
| c.ctx_ = ctx |
| c.mediaInfo_ = gensupport.NewInfoFromResumableMedia(r, size, mediaType) |
| return c |
| } |
| |
| // ProgressUpdater provides a callback function that will be called after every |
| // chunk. It should be a low-latency function in order to not slow down the |
| // upload operation. This should only be called when using ResumableMedia (as |
| // opposed to Media). |
| func (c *UsersMessagesInsertCall) ProgressUpdater(pu googleapi.ProgressUpdater) *UsersMessagesInsertCall { |
| c.mediaInfo_.SetProgressUpdater(pu) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersMessagesInsertCall) Fields(s ...googleapi.Field) *UsersMessagesInsertCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| // This context will supersede any context previously provided to the |
| // ResumableMedia method. |
| func (c *UsersMessagesInsertCall) Context(ctx context.Context) *UsersMessagesInsertCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersMessagesInsertCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersMessagesInsertCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.message) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/messages") |
| if c.mediaInfo_ != nil { |
| urls = googleapi.ResolveRelative(c.s.BasePath, "/upload/gmail/v1/users/{userId}/messages") |
| c.urlParams_.Set("uploadType", c.mediaInfo_.UploadType()) |
| } |
| if body == nil { |
| body = new(bytes.Buffer) |
| reqHeaders.Set("Content-Type", "application/json") |
| } |
| body, getBody, cleanup := c.mediaInfo_.UploadRequest(reqHeaders, body) |
| defer cleanup() |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| req.GetBody = getBody |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.messages.insert" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *Message.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersMessagesInsertCall) Do(opts ...googleapi.CallOption) (*Message, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| rx := c.mediaInfo_.ResumableUpload(res.Header.Get("Location")) |
| if rx != nil { |
| rx.Client = c.s.client |
| rx.UserAgent = c.s.userAgent() |
| ctx := c.ctx_ |
| if ctx == nil { |
| ctx = context.TODO() |
| } |
| res, err = rx.Upload(ctx) |
| if err != nil { |
| return nil, err |
| } |
| defer res.Body.Close() |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| } |
| ret := &Message{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersMessagesListCall struct { |
| s *Service |
| userId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Lists the messages in the user's mailbox. |
| // |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersMessagesService) List(userId string) *UsersMessagesListCall { |
| c := &UsersMessagesListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| return c |
| } |
| |
| // IncludeSpamTrash sets the optional parameter "includeSpamTrash": Include |
| // messages from `SPAM` and `TRASH` in the results. |
| func (c *UsersMessagesListCall) IncludeSpamTrash(includeSpamTrash bool) *UsersMessagesListCall { |
| c.urlParams_.Set("includeSpamTrash", fmt.Sprint(includeSpamTrash)) |
| return c |
| } |
| |
| // LabelIds sets the optional parameter "labelIds": Only return messages with |
| // labels that match all of the specified label IDs. Messages in a thread might |
| // have labels that other messages in the same thread don't have. To learn |
| // more, see Manage labels on messages and threads |
| // (https://developers.google.com/gmail/api/guides/labels#manage_labels_on_messages_threads). |
| func (c *UsersMessagesListCall) LabelIds(labelIds ...string) *UsersMessagesListCall { |
| c.urlParams_.SetMulti("labelIds", append([]string{}, labelIds...)) |
| return c |
| } |
| |
| // MaxResults sets the optional parameter "maxResults": Maximum number of |
| // messages to return. This field defaults to 100. The maximum allowed value |
| // for this field is 500. |
| func (c *UsersMessagesListCall) MaxResults(maxResults int64) *UsersMessagesListCall { |
| c.urlParams_.Set("maxResults", fmt.Sprint(maxResults)) |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": Page token to retrieve a |
| // specific page of results in the list. |
| func (c *UsersMessagesListCall) PageToken(pageToken string) *UsersMessagesListCall { |
| c.urlParams_.Set("pageToken", pageToken) |
| return c |
| } |
| |
| // Q sets the optional parameter "q": Only return messages matching the |
| // specified query. Supports the same query format as the Gmail search box. For |
| // example, "from:someuser@example.com rfc822msgid: is:unread". Parameter |
| // cannot be used when accessing the api using the gmail.metadata scope. |
| func (c *UsersMessagesListCall) Q(q string) *UsersMessagesListCall { |
| c.urlParams_.Set("q", q) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersMessagesListCall) Fields(s ...googleapi.Field) *UsersMessagesListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersMessagesListCall) IfNoneMatch(entityTag string) *UsersMessagesListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersMessagesListCall) Context(ctx context.Context) *UsersMessagesListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersMessagesListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersMessagesListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/messages") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.messages.list" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *ListMessagesResponse.ServerResponse.Header or (if a response was returned |
| // at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified was |
| // returned. |
| func (c *UsersMessagesListCall) Do(opts ...googleapi.CallOption) (*ListMessagesResponse, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &ListMessagesResponse{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| // Pages invokes f for each page of results. |
| // A non-nil error returned from f will halt the iteration. |
| // The provided context supersedes any context provided to the Context method. |
| func (c *UsersMessagesListCall) Pages(ctx context.Context, f func(*ListMessagesResponse) error) error { |
| c.ctx_ = ctx |
| defer c.PageToken(c.urlParams_.Get("pageToken")) |
| for { |
| x, err := c.Do() |
| if err != nil { |
| return err |
| } |
| if err := f(x); err != nil { |
| return err |
| } |
| if x.NextPageToken == "" { |
| return nil |
| } |
| c.PageToken(x.NextPageToken) |
| } |
| } |
| |
| type UsersMessagesModifyCall struct { |
| s *Service |
| userId string |
| id string |
| modifymessagerequest *ModifyMessageRequest |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Modify: Modifies the labels on the specified message. |
| // |
| // - id: The ID of the message to modify. |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersMessagesService) Modify(userId string, id string, modifymessagerequest *ModifyMessageRequest) *UsersMessagesModifyCall { |
| c := &UsersMessagesModifyCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.id = id |
| c.modifymessagerequest = modifymessagerequest |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersMessagesModifyCall) Fields(s ...googleapi.Field) *UsersMessagesModifyCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersMessagesModifyCall) Context(ctx context.Context) *UsersMessagesModifyCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersMessagesModifyCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersMessagesModifyCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.modifymessagerequest) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/messages/{id}/modify") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "id": c.id, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.messages.modify" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *Message.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersMessagesModifyCall) Do(opts ...googleapi.CallOption) (*Message, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &Message{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersMessagesSendCall struct { |
| s *Service |
| userId string |
| message *Message |
| urlParams_ gensupport.URLParams |
| mediaInfo_ *gensupport.MediaInfo |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Send: Sends the specified message to the recipients in the `To`, `Cc`, and |
| // `Bcc` headers. For example usage, see Sending email |
| // (https://developers.google.com/gmail/api/guides/sending). |
| // |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersMessagesService) Send(userId string, message *Message) *UsersMessagesSendCall { |
| c := &UsersMessagesSendCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.message = message |
| return c |
| } |
| |
| // Media specifies the media to upload in one or more chunks. The chunk size |
| // may be controlled by supplying a MediaOption generated by |
| // googleapi.ChunkSize. The chunk size defaults to |
| // googleapi.DefaultUploadChunkSize.The Content-Type header used in the upload |
| // request will be determined by sniffing the contents of r, unless a |
| // MediaOption generated by googleapi.ContentType is supplied. |
| // At most one of Media and ResumableMedia may be set. |
| func (c *UsersMessagesSendCall) Media(r io.Reader, options ...googleapi.MediaOption) *UsersMessagesSendCall { |
| c.mediaInfo_ = gensupport.NewInfoFromMedia(r, options) |
| return c |
| } |
| |
| // ResumableMedia specifies the media to upload in chunks and can be canceled |
| // with ctx. |
| // |
| // Deprecated: use Media instead. |
| // |
| // At most one of Media and ResumableMedia may be set. mediaType identifies the |
| // MIME media type of the upload, such as "image/png". If mediaType is "", it |
| // will be auto-detected. The provided ctx will supersede any context |
| // previously provided to the Context method. |
| func (c *UsersMessagesSendCall) ResumableMedia(ctx context.Context, r io.ReaderAt, size int64, mediaType string) *UsersMessagesSendCall { |
| c.ctx_ = ctx |
| c.mediaInfo_ = gensupport.NewInfoFromResumableMedia(r, size, mediaType) |
| return c |
| } |
| |
| // ProgressUpdater provides a callback function that will be called after every |
| // chunk. It should be a low-latency function in order to not slow down the |
| // upload operation. This should only be called when using ResumableMedia (as |
| // opposed to Media). |
| func (c *UsersMessagesSendCall) ProgressUpdater(pu googleapi.ProgressUpdater) *UsersMessagesSendCall { |
| c.mediaInfo_.SetProgressUpdater(pu) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersMessagesSendCall) Fields(s ...googleapi.Field) *UsersMessagesSendCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| // This context will supersede any context previously provided to the |
| // ResumableMedia method. |
| func (c *UsersMessagesSendCall) Context(ctx context.Context) *UsersMessagesSendCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersMessagesSendCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersMessagesSendCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.message) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/messages/send") |
| if c.mediaInfo_ != nil { |
| urls = googleapi.ResolveRelative(c.s.BasePath, "/upload/gmail/v1/users/{userId}/messages/send") |
| c.urlParams_.Set("uploadType", c.mediaInfo_.UploadType()) |
| } |
| if body == nil { |
| body = new(bytes.Buffer) |
| reqHeaders.Set("Content-Type", "application/json") |
| } |
| body, getBody, cleanup := c.mediaInfo_.UploadRequest(reqHeaders, body) |
| defer cleanup() |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| req.GetBody = getBody |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.messages.send" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *Message.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersMessagesSendCall) Do(opts ...googleapi.CallOption) (*Message, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| rx := c.mediaInfo_.ResumableUpload(res.Header.Get("Location")) |
| if rx != nil { |
| rx.Client = c.s.client |
| rx.UserAgent = c.s.userAgent() |
| ctx := c.ctx_ |
| if ctx == nil { |
| ctx = context.TODO() |
| } |
| res, err = rx.Upload(ctx) |
| if err != nil { |
| return nil, err |
| } |
| defer res.Body.Close() |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| } |
| ret := &Message{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersMessagesTrashCall struct { |
| s *Service |
| userId string |
| id string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Trash: Moves the specified message to the trash. |
| // |
| // - id: The ID of the message to Trash. |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersMessagesService) Trash(userId string, id string) *UsersMessagesTrashCall { |
| c := &UsersMessagesTrashCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.id = id |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersMessagesTrashCall) Fields(s ...googleapi.Field) *UsersMessagesTrashCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersMessagesTrashCall) Context(ctx context.Context) *UsersMessagesTrashCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersMessagesTrashCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersMessagesTrashCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/messages/{id}/trash") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "id": c.id, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.messages.trash" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *Message.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersMessagesTrashCall) Do(opts ...googleapi.CallOption) (*Message, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &Message{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersMessagesUntrashCall struct { |
| s *Service |
| userId string |
| id string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Untrash: Removes the specified message from the trash. |
| // |
| // - id: The ID of the message to remove from Trash. |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersMessagesService) Untrash(userId string, id string) *UsersMessagesUntrashCall { |
| c := &UsersMessagesUntrashCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.id = id |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersMessagesUntrashCall) Fields(s ...googleapi.Field) *UsersMessagesUntrashCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersMessagesUntrashCall) Context(ctx context.Context) *UsersMessagesUntrashCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersMessagesUntrashCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersMessagesUntrashCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/messages/{id}/untrash") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "id": c.id, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.messages.untrash" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *Message.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersMessagesUntrashCall) Do(opts ...googleapi.CallOption) (*Message, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &Message{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersMessagesAttachmentsGetCall struct { |
| s *Service |
| userId string |
| messageId string |
| id string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Gets the specified message attachment. |
| // |
| // - id: The ID of the attachment. |
| // - messageId: The ID of the message containing the attachment. |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersMessagesAttachmentsService) Get(userId string, messageId string, id string) *UsersMessagesAttachmentsGetCall { |
| c := &UsersMessagesAttachmentsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.messageId = messageId |
| c.id = id |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersMessagesAttachmentsGetCall) Fields(s ...googleapi.Field) *UsersMessagesAttachmentsGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersMessagesAttachmentsGetCall) IfNoneMatch(entityTag string) *UsersMessagesAttachmentsGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersMessagesAttachmentsGetCall) Context(ctx context.Context) *UsersMessagesAttachmentsGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersMessagesAttachmentsGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersMessagesAttachmentsGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/messages/{messageId}/attachments/{id}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "messageId": c.messageId, |
| "id": c.id, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.messages.attachments.get" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *MessagePartBody.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified was |
| // returned. |
| func (c *UsersMessagesAttachmentsGetCall) Do(opts ...googleapi.CallOption) (*MessagePartBody, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &MessagePartBody{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsGetAutoForwardingCall struct { |
| s *Service |
| userId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // GetAutoForwarding: Gets the auto-forwarding setting for the specified |
| // account. |
| // |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsService) GetAutoForwarding(userId string) *UsersSettingsGetAutoForwardingCall { |
| c := &UsersSettingsGetAutoForwardingCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsGetAutoForwardingCall) Fields(s ...googleapi.Field) *UsersSettingsGetAutoForwardingCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersSettingsGetAutoForwardingCall) IfNoneMatch(entityTag string) *UsersSettingsGetAutoForwardingCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsGetAutoForwardingCall) Context(ctx context.Context) *UsersSettingsGetAutoForwardingCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsGetAutoForwardingCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsGetAutoForwardingCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/autoForwarding") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.getAutoForwarding" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *AutoForwarding.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersSettingsGetAutoForwardingCall) Do(opts ...googleapi.CallOption) (*AutoForwarding, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &AutoForwarding{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsGetImapCall struct { |
| s *Service |
| userId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // GetImap: Gets IMAP settings. |
| // |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsService) GetImap(userId string) *UsersSettingsGetImapCall { |
| c := &UsersSettingsGetImapCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsGetImapCall) Fields(s ...googleapi.Field) *UsersSettingsGetImapCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersSettingsGetImapCall) IfNoneMatch(entityTag string) *UsersSettingsGetImapCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsGetImapCall) Context(ctx context.Context) *UsersSettingsGetImapCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsGetImapCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsGetImapCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/imap") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.getImap" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *ImapSettings.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersSettingsGetImapCall) Do(opts ...googleapi.CallOption) (*ImapSettings, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &ImapSettings{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsGetLanguageCall struct { |
| s *Service |
| userId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // GetLanguage: Gets language settings. |
| // |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsService) GetLanguage(userId string) *UsersSettingsGetLanguageCall { |
| c := &UsersSettingsGetLanguageCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsGetLanguageCall) Fields(s ...googleapi.Field) *UsersSettingsGetLanguageCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersSettingsGetLanguageCall) IfNoneMatch(entityTag string) *UsersSettingsGetLanguageCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsGetLanguageCall) Context(ctx context.Context) *UsersSettingsGetLanguageCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsGetLanguageCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsGetLanguageCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/language") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.getLanguage" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *LanguageSettings.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified was |
| // returned. |
| func (c *UsersSettingsGetLanguageCall) Do(opts ...googleapi.CallOption) (*LanguageSettings, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &LanguageSettings{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsGetPopCall struct { |
| s *Service |
| userId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // GetPop: Gets POP settings. |
| // |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsService) GetPop(userId string) *UsersSettingsGetPopCall { |
| c := &UsersSettingsGetPopCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsGetPopCall) Fields(s ...googleapi.Field) *UsersSettingsGetPopCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersSettingsGetPopCall) IfNoneMatch(entityTag string) *UsersSettingsGetPopCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsGetPopCall) Context(ctx context.Context) *UsersSettingsGetPopCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsGetPopCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsGetPopCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/pop") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.getPop" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *PopSettings.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersSettingsGetPopCall) Do(opts ...googleapi.CallOption) (*PopSettings, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &PopSettings{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsGetVacationCall struct { |
| s *Service |
| userId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // GetVacation: Gets vacation responder settings. |
| // |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsService) GetVacation(userId string) *UsersSettingsGetVacationCall { |
| c := &UsersSettingsGetVacationCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsGetVacationCall) Fields(s ...googleapi.Field) *UsersSettingsGetVacationCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersSettingsGetVacationCall) IfNoneMatch(entityTag string) *UsersSettingsGetVacationCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsGetVacationCall) Context(ctx context.Context) *UsersSettingsGetVacationCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsGetVacationCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsGetVacationCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/vacation") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.getVacation" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *VacationSettings.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified was |
| // returned. |
| func (c *UsersSettingsGetVacationCall) Do(opts ...googleapi.CallOption) (*VacationSettings, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &VacationSettings{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsUpdateAutoForwardingCall struct { |
| s *Service |
| userId string |
| autoforwarding *AutoForwarding |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // UpdateAutoForwarding: Updates the auto-forwarding setting for the specified |
| // account. A verified forwarding address must be specified when |
| // auto-forwarding is enabled. This method is only available to service account |
| // clients that have been delegated domain-wide authority. |
| // |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsService) UpdateAutoForwarding(userId string, autoforwarding *AutoForwarding) *UsersSettingsUpdateAutoForwardingCall { |
| c := &UsersSettingsUpdateAutoForwardingCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.autoforwarding = autoforwarding |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsUpdateAutoForwardingCall) Fields(s ...googleapi.Field) *UsersSettingsUpdateAutoForwardingCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsUpdateAutoForwardingCall) Context(ctx context.Context) *UsersSettingsUpdateAutoForwardingCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsUpdateAutoForwardingCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsUpdateAutoForwardingCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.autoforwarding) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/autoForwarding") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("PUT", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.updateAutoForwarding" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *AutoForwarding.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersSettingsUpdateAutoForwardingCall) Do(opts ...googleapi.CallOption) (*AutoForwarding, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &AutoForwarding{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsUpdateImapCall struct { |
| s *Service |
| userId string |
| imapsettings *ImapSettings |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // UpdateImap: Updates IMAP settings. |
| // |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsService) UpdateImap(userId string, imapsettings *ImapSettings) *UsersSettingsUpdateImapCall { |
| c := &UsersSettingsUpdateImapCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.imapsettings = imapsettings |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsUpdateImapCall) Fields(s ...googleapi.Field) *UsersSettingsUpdateImapCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsUpdateImapCall) Context(ctx context.Context) *UsersSettingsUpdateImapCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsUpdateImapCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsUpdateImapCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.imapsettings) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/imap") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("PUT", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.updateImap" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *ImapSettings.ServerResponse.Header or (if a response was returned at all) |
| // in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersSettingsUpdateImapCall) Do(opts ...googleapi.CallOption) (*ImapSettings, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &ImapSettings{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsUpdateLanguageCall struct { |
| s *Service |
| userId string |
| languagesettings *LanguageSettings |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // UpdateLanguage: Updates language settings. If successful, the return object |
| // contains the `displayLanguage` that was saved for the user, which may differ |
| // from the value passed into the request. This is because the requested |
| // `displayLanguage` may not be directly supported by Gmail but have a close |
| // variant that is, and so the variant may be chosen and saved instead. |
| // |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsService) UpdateLanguage(userId string, languagesettings *LanguageSettings) *UsersSettingsUpdateLanguageCall { |
| c := &UsersSettingsUpdateLanguageCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.languagesettings = languagesettings |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsUpdateLanguageCall) Fields(s ...googleapi.Field) *UsersSettingsUpdateLanguageCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsUpdateLanguageCall) Context(ctx context.Context) *UsersSettingsUpdateLanguageCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsUpdateLanguageCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsUpdateLanguageCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.languagesettings) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/language") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("PUT", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.updateLanguage" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *LanguageSettings.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified was |
| // returned. |
| func (c *UsersSettingsUpdateLanguageCall) Do(opts ...googleapi.CallOption) (*LanguageSettings, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &LanguageSettings{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsUpdatePopCall struct { |
| s *Service |
| userId string |
| popsettings *PopSettings |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // UpdatePop: Updates POP settings. |
| // |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsService) UpdatePop(userId string, popsettings *PopSettings) *UsersSettingsUpdatePopCall { |
| c := &UsersSettingsUpdatePopCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.popsettings = popsettings |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsUpdatePopCall) Fields(s ...googleapi.Field) *UsersSettingsUpdatePopCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsUpdatePopCall) Context(ctx context.Context) *UsersSettingsUpdatePopCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsUpdatePopCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsUpdatePopCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.popsettings) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/pop") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("PUT", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.updatePop" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *PopSettings.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersSettingsUpdatePopCall) Do(opts ...googleapi.CallOption) (*PopSettings, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &PopSettings{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsUpdateVacationCall struct { |
| s *Service |
| userId string |
| vacationsettings *VacationSettings |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // UpdateVacation: Updates vacation responder settings. |
| // |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsService) UpdateVacation(userId string, vacationsettings *VacationSettings) *UsersSettingsUpdateVacationCall { |
| c := &UsersSettingsUpdateVacationCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.vacationsettings = vacationsettings |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsUpdateVacationCall) Fields(s ...googleapi.Field) *UsersSettingsUpdateVacationCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsUpdateVacationCall) Context(ctx context.Context) *UsersSettingsUpdateVacationCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsUpdateVacationCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsUpdateVacationCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.vacationsettings) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/vacation") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("PUT", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.updateVacation" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *VacationSettings.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified was |
| // returned. |
| func (c *UsersSettingsUpdateVacationCall) Do(opts ...googleapi.CallOption) (*VacationSettings, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &VacationSettings{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsCseIdentitiesCreateCall struct { |
| s *Service |
| userId string |
| cseidentity *CseIdentity |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Create: Creates and configures a client-side encryption identity that's |
| // authorized to send mail from the user account. Google publishes the S/MIME |
| // certificate to a shared domain-wide directory so that people within a Google |
| // Workspace organization can encrypt and send mail to the identity. |
| // |
| // - userId: The requester's primary email address. To indicate the |
| // authenticated user, you can use the special value `me`. |
| func (r *UsersSettingsCseIdentitiesService) Create(userId string, cseidentity *CseIdentity) *UsersSettingsCseIdentitiesCreateCall { |
| c := &UsersSettingsCseIdentitiesCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.cseidentity = cseidentity |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsCseIdentitiesCreateCall) Fields(s ...googleapi.Field) *UsersSettingsCseIdentitiesCreateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsCseIdentitiesCreateCall) Context(ctx context.Context) *UsersSettingsCseIdentitiesCreateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsCseIdentitiesCreateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsCseIdentitiesCreateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.cseidentity) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/cse/identities") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.cse.identities.create" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *CseIdentity.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersSettingsCseIdentitiesCreateCall) Do(opts ...googleapi.CallOption) (*CseIdentity, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &CseIdentity{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsCseIdentitiesDeleteCall struct { |
| s *Service |
| userId string |
| cseEmailAddress string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Deletes a client-side encryption identity. The authenticated user |
| // can no longer use the identity to send encrypted messages. You cannot |
| // restore the identity after you delete it. Instead, use the CreateCseIdentity |
| // method to create another identity with the same configuration. |
| // |
| // - cseEmailAddress: The primary email address associated with the client-side |
| // encryption identity configuration that's removed. |
| // - userId: The requester's primary email address. To indicate the |
| // authenticated user, you can use the special value `me`. |
| func (r *UsersSettingsCseIdentitiesService) Delete(userId string, cseEmailAddress string) *UsersSettingsCseIdentitiesDeleteCall { |
| c := &UsersSettingsCseIdentitiesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.cseEmailAddress = cseEmailAddress |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsCseIdentitiesDeleteCall) Fields(s ...googleapi.Field) *UsersSettingsCseIdentitiesDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsCseIdentitiesDeleteCall) Context(ctx context.Context) *UsersSettingsCseIdentitiesDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsCseIdentitiesDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsCseIdentitiesDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/cse/identities/{cseEmailAddress}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("DELETE", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "cseEmailAddress": c.cseEmailAddress, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.cse.identities.delete" call. |
| func (c *UsersSettingsCseIdentitiesDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return gensupport.WrapError(err) |
| } |
| return nil |
| } |
| |
| type UsersSettingsCseIdentitiesGetCall struct { |
| s *Service |
| userId string |
| cseEmailAddress string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Retrieves a client-side encryption identity configuration. |
| // |
| // - cseEmailAddress: The primary email address associated with the client-side |
| // encryption identity configuration that's retrieved. |
| // - userId: The requester's primary email address. To indicate the |
| // authenticated user, you can use the special value `me`. |
| func (r *UsersSettingsCseIdentitiesService) Get(userId string, cseEmailAddress string) *UsersSettingsCseIdentitiesGetCall { |
| c := &UsersSettingsCseIdentitiesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.cseEmailAddress = cseEmailAddress |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsCseIdentitiesGetCall) Fields(s ...googleapi.Field) *UsersSettingsCseIdentitiesGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersSettingsCseIdentitiesGetCall) IfNoneMatch(entityTag string) *UsersSettingsCseIdentitiesGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsCseIdentitiesGetCall) Context(ctx context.Context) *UsersSettingsCseIdentitiesGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsCseIdentitiesGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsCseIdentitiesGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/cse/identities/{cseEmailAddress}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "cseEmailAddress": c.cseEmailAddress, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.cse.identities.get" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *CseIdentity.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersSettingsCseIdentitiesGetCall) Do(opts ...googleapi.CallOption) (*CseIdentity, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &CseIdentity{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsCseIdentitiesListCall struct { |
| s *Service |
| userId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Lists the client-side encrypted identities for an authenticated user. |
| // |
| // - userId: The requester's primary email address. To indicate the |
| // authenticated user, you can use the special value `me`. |
| func (r *UsersSettingsCseIdentitiesService) List(userId string) *UsersSettingsCseIdentitiesListCall { |
| c := &UsersSettingsCseIdentitiesListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| return c |
| } |
| |
| // PageSize sets the optional parameter "pageSize": The number of identities to |
| // return. If not provided, the page size will default to 20 entries. |
| func (c *UsersSettingsCseIdentitiesListCall) PageSize(pageSize int64) *UsersSettingsCseIdentitiesListCall { |
| c.urlParams_.Set("pageSize", fmt.Sprint(pageSize)) |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": Pagination token |
| // indicating which page of identities to return. If the token is not supplied, |
| // then the API will return the first page of results. |
| func (c *UsersSettingsCseIdentitiesListCall) PageToken(pageToken string) *UsersSettingsCseIdentitiesListCall { |
| c.urlParams_.Set("pageToken", pageToken) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsCseIdentitiesListCall) Fields(s ...googleapi.Field) *UsersSettingsCseIdentitiesListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersSettingsCseIdentitiesListCall) IfNoneMatch(entityTag string) *UsersSettingsCseIdentitiesListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsCseIdentitiesListCall) Context(ctx context.Context) *UsersSettingsCseIdentitiesListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsCseIdentitiesListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsCseIdentitiesListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/cse/identities") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.cse.identities.list" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *ListCseIdentitiesResponse.ServerResponse.Header or (if a response was |
| // returned at all) in error.(*googleapi.Error).Header. Use |
| // googleapi.IsNotModified to check whether the returned error was because |
| // http.StatusNotModified was returned. |
| func (c *UsersSettingsCseIdentitiesListCall) Do(opts ...googleapi.CallOption) (*ListCseIdentitiesResponse, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &ListCseIdentitiesResponse{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| // Pages invokes f for each page of results. |
| // A non-nil error returned from f will halt the iteration. |
| // The provided context supersedes any context provided to the Context method. |
| func (c *UsersSettingsCseIdentitiesListCall) Pages(ctx context.Context, f func(*ListCseIdentitiesResponse) error) error { |
| c.ctx_ = ctx |
| defer c.PageToken(c.urlParams_.Get("pageToken")) |
| for { |
| x, err := c.Do() |
| if err != nil { |
| return err |
| } |
| if err := f(x); err != nil { |
| return err |
| } |
| if x.NextPageToken == "" { |
| return nil |
| } |
| c.PageToken(x.NextPageToken) |
| } |
| } |
| |
| type UsersSettingsCseIdentitiesPatchCall struct { |
| s *Service |
| userId string |
| emailAddress string |
| cseidentity *CseIdentity |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Patch: Associates a different key pair with an existing client-side |
| // encryption identity. The updated key pair must validate against Google's |
| // S/MIME certificate profiles (https://support.google.com/a/answer/7300887). |
| // |
| // - emailAddress: The email address of the client-side encryption identity to |
| // update. |
| // - userId: The requester's primary email address. To indicate the |
| // authenticated user, you can use the special value `me`. |
| func (r *UsersSettingsCseIdentitiesService) Patch(userId string, emailAddress string, cseidentity *CseIdentity) *UsersSettingsCseIdentitiesPatchCall { |
| c := &UsersSettingsCseIdentitiesPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.emailAddress = emailAddress |
| c.cseidentity = cseidentity |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsCseIdentitiesPatchCall) Fields(s ...googleapi.Field) *UsersSettingsCseIdentitiesPatchCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsCseIdentitiesPatchCall) Context(ctx context.Context) *UsersSettingsCseIdentitiesPatchCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsCseIdentitiesPatchCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsCseIdentitiesPatchCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.cseidentity) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/cse/identities/{emailAddress}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("PATCH", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "emailAddress": c.emailAddress, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.cse.identities.patch" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *CseIdentity.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersSettingsCseIdentitiesPatchCall) Do(opts ...googleapi.CallOption) (*CseIdentity, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &CseIdentity{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsCseKeypairsCreateCall struct { |
| s *Service |
| userId string |
| csekeypair *CseKeyPair |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Create: Creates and uploads a client-side encryption S/MIME public key |
| // certificate chain and private key metadata for the authenticated user. |
| // |
| // - userId: The requester's primary email address. To indicate the |
| // authenticated user, you can use the special value `me`. |
| func (r *UsersSettingsCseKeypairsService) Create(userId string, csekeypair *CseKeyPair) *UsersSettingsCseKeypairsCreateCall { |
| c := &UsersSettingsCseKeypairsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.csekeypair = csekeypair |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsCseKeypairsCreateCall) Fields(s ...googleapi.Field) *UsersSettingsCseKeypairsCreateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsCseKeypairsCreateCall) Context(ctx context.Context) *UsersSettingsCseKeypairsCreateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsCseKeypairsCreateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsCseKeypairsCreateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.csekeypair) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/cse/keypairs") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.cse.keypairs.create" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *CseKeyPair.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersSettingsCseKeypairsCreateCall) Do(opts ...googleapi.CallOption) (*CseKeyPair, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &CseKeyPair{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsCseKeypairsDisableCall struct { |
| s *Service |
| userId string |
| keyPairId string |
| disablecsekeypairrequest *DisableCseKeyPairRequest |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Disable: Turns off a client-side encryption key pair. The authenticated user |
| // can no longer use the key pair to decrypt incoming CSE message texts or sign |
| // outgoing CSE mail. To regain access, use the EnableCseKeyPair to turn on the |
| // key pair. After 30 days, you can permanently delete the key pair by using |
| // the ObliterateCseKeyPair method. |
| // |
| // - keyPairId: The identifier of the key pair to turn off. |
| // - userId: The requester's primary email address. To indicate the |
| // authenticated user, you can use the special value `me`. |
| func (r *UsersSettingsCseKeypairsService) Disable(userId string, keyPairId string, disablecsekeypairrequest *DisableCseKeyPairRequest) *UsersSettingsCseKeypairsDisableCall { |
| c := &UsersSettingsCseKeypairsDisableCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.keyPairId = keyPairId |
| c.disablecsekeypairrequest = disablecsekeypairrequest |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsCseKeypairsDisableCall) Fields(s ...googleapi.Field) *UsersSettingsCseKeypairsDisableCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsCseKeypairsDisableCall) Context(ctx context.Context) *UsersSettingsCseKeypairsDisableCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsCseKeypairsDisableCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsCseKeypairsDisableCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.disablecsekeypairrequest) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/cse/keypairs/{keyPairId}:disable") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "keyPairId": c.keyPairId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.cse.keypairs.disable" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *CseKeyPair.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersSettingsCseKeypairsDisableCall) Do(opts ...googleapi.CallOption) (*CseKeyPair, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &CseKeyPair{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsCseKeypairsEnableCall struct { |
| s *Service |
| userId string |
| keyPairId string |
| enablecsekeypairrequest *EnableCseKeyPairRequest |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Enable: Turns on a client-side encryption key pair that was turned off. The |
| // key pair becomes active again for any associated client-side encryption |
| // identities. |
| // |
| // - keyPairId: The identifier of the key pair to turn on. |
| // - userId: The requester's primary email address. To indicate the |
| // authenticated user, you can use the special value `me`. |
| func (r *UsersSettingsCseKeypairsService) Enable(userId string, keyPairId string, enablecsekeypairrequest *EnableCseKeyPairRequest) *UsersSettingsCseKeypairsEnableCall { |
| c := &UsersSettingsCseKeypairsEnableCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.keyPairId = keyPairId |
| c.enablecsekeypairrequest = enablecsekeypairrequest |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsCseKeypairsEnableCall) Fields(s ...googleapi.Field) *UsersSettingsCseKeypairsEnableCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsCseKeypairsEnableCall) Context(ctx context.Context) *UsersSettingsCseKeypairsEnableCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsCseKeypairsEnableCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsCseKeypairsEnableCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.enablecsekeypairrequest) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/cse/keypairs/{keyPairId}:enable") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "keyPairId": c.keyPairId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.cse.keypairs.enable" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *CseKeyPair.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersSettingsCseKeypairsEnableCall) Do(opts ...googleapi.CallOption) (*CseKeyPair, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &CseKeyPair{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsCseKeypairsGetCall struct { |
| s *Service |
| userId string |
| keyPairId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Retrieves an existing client-side encryption key pair. |
| // |
| // - keyPairId: The identifier of the key pair to retrieve. |
| // - userId: The requester's primary email address. To indicate the |
| // authenticated user, you can use the special value `me`. |
| func (r *UsersSettingsCseKeypairsService) Get(userId string, keyPairId string) *UsersSettingsCseKeypairsGetCall { |
| c := &UsersSettingsCseKeypairsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.keyPairId = keyPairId |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsCseKeypairsGetCall) Fields(s ...googleapi.Field) *UsersSettingsCseKeypairsGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersSettingsCseKeypairsGetCall) IfNoneMatch(entityTag string) *UsersSettingsCseKeypairsGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsCseKeypairsGetCall) Context(ctx context.Context) *UsersSettingsCseKeypairsGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsCseKeypairsGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsCseKeypairsGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/cse/keypairs/{keyPairId}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "keyPairId": c.keyPairId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.cse.keypairs.get" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *CseKeyPair.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersSettingsCseKeypairsGetCall) Do(opts ...googleapi.CallOption) (*CseKeyPair, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &CseKeyPair{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsCseKeypairsListCall struct { |
| s *Service |
| userId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Lists client-side encryption key pairs for an authenticated user. |
| // |
| // - userId: The requester's primary email address. To indicate the |
| // authenticated user, you can use the special value `me`. |
| func (r *UsersSettingsCseKeypairsService) List(userId string) *UsersSettingsCseKeypairsListCall { |
| c := &UsersSettingsCseKeypairsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| return c |
| } |
| |
| // PageSize sets the optional parameter "pageSize": The number of key pairs to |
| // return. If not provided, the page size will default to 20 entries. |
| func (c *UsersSettingsCseKeypairsListCall) PageSize(pageSize int64) *UsersSettingsCseKeypairsListCall { |
| c.urlParams_.Set("pageSize", fmt.Sprint(pageSize)) |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": Pagination token |
| // indicating which page of key pairs to return. If the token is not supplied, |
| // then the API will return the first page of results. |
| func (c *UsersSettingsCseKeypairsListCall) PageToken(pageToken string) *UsersSettingsCseKeypairsListCall { |
| c.urlParams_.Set("pageToken", pageToken) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsCseKeypairsListCall) Fields(s ...googleapi.Field) *UsersSettingsCseKeypairsListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersSettingsCseKeypairsListCall) IfNoneMatch(entityTag string) *UsersSettingsCseKeypairsListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsCseKeypairsListCall) Context(ctx context.Context) *UsersSettingsCseKeypairsListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsCseKeypairsListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsCseKeypairsListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/cse/keypairs") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.cse.keypairs.list" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *ListCseKeyPairsResponse.ServerResponse.Header or (if a response was |
| // returned at all) in error.(*googleapi.Error).Header. Use |
| // googleapi.IsNotModified to check whether the returned error was because |
| // http.StatusNotModified was returned. |
| func (c *UsersSettingsCseKeypairsListCall) Do(opts ...googleapi.CallOption) (*ListCseKeyPairsResponse, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &ListCseKeyPairsResponse{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| // Pages invokes f for each page of results. |
| // A non-nil error returned from f will halt the iteration. |
| // The provided context supersedes any context provided to the Context method. |
| func (c *UsersSettingsCseKeypairsListCall) Pages(ctx context.Context, f func(*ListCseKeyPairsResponse) error) error { |
| c.ctx_ = ctx |
| defer c.PageToken(c.urlParams_.Get("pageToken")) |
| for { |
| x, err := c.Do() |
| if err != nil { |
| return err |
| } |
| if err := f(x); err != nil { |
| return err |
| } |
| if x.NextPageToken == "" { |
| return nil |
| } |
| c.PageToken(x.NextPageToken) |
| } |
| } |
| |
| type UsersSettingsCseKeypairsObliterateCall struct { |
| s *Service |
| userId string |
| keyPairId string |
| obliteratecsekeypairrequest *ObliterateCseKeyPairRequest |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Obliterate: Deletes a client-side encryption key pair permanently and |
| // immediately. You can only permanently delete key pairs that have been turned |
| // off for more than 30 days. To turn off a key pair, use the DisableCseKeyPair |
| // method. Gmail can't restore or decrypt any messages that were encrypted by |
| // an obliterated key. Authenticated users and Google Workspace administrators |
| // lose access to reading the encrypted messages. |
| // |
| // - keyPairId: The identifier of the key pair to obliterate. |
| // - userId: The requester's primary email address. To indicate the |
| // authenticated user, you can use the special value `me`. |
| func (r *UsersSettingsCseKeypairsService) Obliterate(userId string, keyPairId string, obliteratecsekeypairrequest *ObliterateCseKeyPairRequest) *UsersSettingsCseKeypairsObliterateCall { |
| c := &UsersSettingsCseKeypairsObliterateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.keyPairId = keyPairId |
| c.obliteratecsekeypairrequest = obliteratecsekeypairrequest |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsCseKeypairsObliterateCall) Fields(s ...googleapi.Field) *UsersSettingsCseKeypairsObliterateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsCseKeypairsObliterateCall) Context(ctx context.Context) *UsersSettingsCseKeypairsObliterateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsCseKeypairsObliterateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsCseKeypairsObliterateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.obliteratecsekeypairrequest) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/cse/keypairs/{keyPairId}:obliterate") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "keyPairId": c.keyPairId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.cse.keypairs.obliterate" call. |
| func (c *UsersSettingsCseKeypairsObliterateCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return gensupport.WrapError(err) |
| } |
| return nil |
| } |
| |
| type UsersSettingsDelegatesCreateCall struct { |
| s *Service |
| userId string |
| delegate *Delegate |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Create: Adds a delegate with its verification status set directly to |
| // `accepted`, without sending any verification email. The delegate user must |
| // be a member of the same Google Workspace organization as the delegator user. |
| // Gmail imposes limitations on the number of delegates and delegators each |
| // user in a Google Workspace organization can have. These limits depend on |
| // your organization, but in general each user can have up to 25 delegates and |
| // up to 10 delegators. Note that a delegate user must be referred to by their |
| // primary email address, and not an email alias. Also note that when a new |
| // delegate is created, there may be up to a one minute delay before the new |
| // delegate is available for use. This method is only available to service |
| // account clients that have been delegated domain-wide authority. |
| // |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsDelegatesService) Create(userId string, delegate *Delegate) *UsersSettingsDelegatesCreateCall { |
| c := &UsersSettingsDelegatesCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.delegate = delegate |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsDelegatesCreateCall) Fields(s ...googleapi.Field) *UsersSettingsDelegatesCreateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsDelegatesCreateCall) Context(ctx context.Context) *UsersSettingsDelegatesCreateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsDelegatesCreateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsDelegatesCreateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.delegate) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/delegates") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.delegates.create" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *Delegate.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersSettingsDelegatesCreateCall) Do(opts ...googleapi.CallOption) (*Delegate, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &Delegate{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsDelegatesDeleteCall struct { |
| s *Service |
| userId string |
| delegateEmail string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Removes the specified delegate (which can be of any verification |
| // status), and revokes any verification that may have been required for using |
| // it. Note that a delegate user must be referred to by their primary email |
| // address, and not an email alias. This method is only available to service |
| // account clients that have been delegated domain-wide authority. |
| // |
| // - delegateEmail: The email address of the user to be removed as a delegate. |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsDelegatesService) Delete(userId string, delegateEmail string) *UsersSettingsDelegatesDeleteCall { |
| c := &UsersSettingsDelegatesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.delegateEmail = delegateEmail |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsDelegatesDeleteCall) Fields(s ...googleapi.Field) *UsersSettingsDelegatesDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsDelegatesDeleteCall) Context(ctx context.Context) *UsersSettingsDelegatesDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsDelegatesDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsDelegatesDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/delegates/{delegateEmail}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("DELETE", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "delegateEmail": c.delegateEmail, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.delegates.delete" call. |
| func (c *UsersSettingsDelegatesDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return gensupport.WrapError(err) |
| } |
| return nil |
| } |
| |
| type UsersSettingsDelegatesGetCall struct { |
| s *Service |
| userId string |
| delegateEmail string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Gets the specified delegate. Note that a delegate user must be referred |
| // to by their primary email address, and not an email alias. This method is |
| // only available to service account clients that have been delegated |
| // domain-wide authority. |
| // |
| // - delegateEmail: The email address of the user whose delegate relationship |
| // is to be retrieved. |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsDelegatesService) Get(userId string, delegateEmail string) *UsersSettingsDelegatesGetCall { |
| c := &UsersSettingsDelegatesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.delegateEmail = delegateEmail |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsDelegatesGetCall) Fields(s ...googleapi.Field) *UsersSettingsDelegatesGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersSettingsDelegatesGetCall) IfNoneMatch(entityTag string) *UsersSettingsDelegatesGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsDelegatesGetCall) Context(ctx context.Context) *UsersSettingsDelegatesGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsDelegatesGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsDelegatesGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/delegates/{delegateEmail}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "delegateEmail": c.delegateEmail, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.delegates.get" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *Delegate.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersSettingsDelegatesGetCall) Do(opts ...googleapi.CallOption) (*Delegate, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &Delegate{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsDelegatesListCall struct { |
| s *Service |
| userId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Lists the delegates for the specified account. This method is only |
| // available to service account clients that have been delegated domain-wide |
| // authority. |
| // |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsDelegatesService) List(userId string) *UsersSettingsDelegatesListCall { |
| c := &UsersSettingsDelegatesListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsDelegatesListCall) Fields(s ...googleapi.Field) *UsersSettingsDelegatesListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersSettingsDelegatesListCall) IfNoneMatch(entityTag string) *UsersSettingsDelegatesListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsDelegatesListCall) Context(ctx context.Context) *UsersSettingsDelegatesListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsDelegatesListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsDelegatesListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/delegates") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.delegates.list" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *ListDelegatesResponse.ServerResponse.Header or (if a response was returned |
| // at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified was |
| // returned. |
| func (c *UsersSettingsDelegatesListCall) Do(opts ...googleapi.CallOption) (*ListDelegatesResponse, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &ListDelegatesResponse{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsFiltersCreateCall struct { |
| s *Service |
| userId string |
| filter *Filter |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Create: Creates a filter. Note: you can only create a maximum of 1,000 |
| // filters. |
| // |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsFiltersService) Create(userId string, filter *Filter) *UsersSettingsFiltersCreateCall { |
| c := &UsersSettingsFiltersCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.filter = filter |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsFiltersCreateCall) Fields(s ...googleapi.Field) *UsersSettingsFiltersCreateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsFiltersCreateCall) Context(ctx context.Context) *UsersSettingsFiltersCreateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsFiltersCreateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsFiltersCreateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.filter) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/filters") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.filters.create" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *Filter.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersSettingsFiltersCreateCall) Do(opts ...googleapi.CallOption) (*Filter, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &Filter{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsFiltersDeleteCall struct { |
| s *Service |
| userId string |
| id string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Immediately and permanently deletes the specified filter. |
| // |
| // - id: The ID of the filter to be deleted. |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsFiltersService) Delete(userId string, id string) *UsersSettingsFiltersDeleteCall { |
| c := &UsersSettingsFiltersDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.id = id |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsFiltersDeleteCall) Fields(s ...googleapi.Field) *UsersSettingsFiltersDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsFiltersDeleteCall) Context(ctx context.Context) *UsersSettingsFiltersDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsFiltersDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsFiltersDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/filters/{id}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("DELETE", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "id": c.id, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.filters.delete" call. |
| func (c *UsersSettingsFiltersDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return gensupport.WrapError(err) |
| } |
| return nil |
| } |
| |
| type UsersSettingsFiltersGetCall struct { |
| s *Service |
| userId string |
| id string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Gets a filter. |
| // |
| // - id: The ID of the filter to be fetched. |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsFiltersService) Get(userId string, id string) *UsersSettingsFiltersGetCall { |
| c := &UsersSettingsFiltersGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.id = id |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsFiltersGetCall) Fields(s ...googleapi.Field) *UsersSettingsFiltersGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersSettingsFiltersGetCall) IfNoneMatch(entityTag string) *UsersSettingsFiltersGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsFiltersGetCall) Context(ctx context.Context) *UsersSettingsFiltersGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsFiltersGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsFiltersGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/filters/{id}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "id": c.id, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.filters.get" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *Filter.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersSettingsFiltersGetCall) Do(opts ...googleapi.CallOption) (*Filter, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &Filter{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsFiltersListCall struct { |
| s *Service |
| userId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Lists the message filters of a Gmail user. |
| // |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsFiltersService) List(userId string) *UsersSettingsFiltersListCall { |
| c := &UsersSettingsFiltersListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsFiltersListCall) Fields(s ...googleapi.Field) *UsersSettingsFiltersListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersSettingsFiltersListCall) IfNoneMatch(entityTag string) *UsersSettingsFiltersListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsFiltersListCall) Context(ctx context.Context) *UsersSettingsFiltersListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsFiltersListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsFiltersListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/filters") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.filters.list" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *ListFiltersResponse.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified was |
| // returned. |
| func (c *UsersSettingsFiltersListCall) Do(opts ...googleapi.CallOption) (*ListFiltersResponse, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &ListFiltersResponse{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsForwardingAddressesCreateCall struct { |
| s *Service |
| userId string |
| forwardingaddress *ForwardingAddress |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Create: Creates a forwarding address. If ownership verification is required, |
| // a message will be sent to the recipient and the resource's verification |
| // status will be set to `pending`; otherwise, the resource will be created |
| // with verification status set to `accepted`. This method is only available to |
| // service account clients that have been delegated domain-wide authority. |
| // |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsForwardingAddressesService) Create(userId string, forwardingaddress *ForwardingAddress) *UsersSettingsForwardingAddressesCreateCall { |
| c := &UsersSettingsForwardingAddressesCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.forwardingaddress = forwardingaddress |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsForwardingAddressesCreateCall) Fields(s ...googleapi.Field) *UsersSettingsForwardingAddressesCreateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsForwardingAddressesCreateCall) Context(ctx context.Context) *UsersSettingsForwardingAddressesCreateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsForwardingAddressesCreateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsForwardingAddressesCreateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.forwardingaddress) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/forwardingAddresses") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.forwardingAddresses.create" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *ForwardingAddress.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified was |
| // returned. |
| func (c *UsersSettingsForwardingAddressesCreateCall) Do(opts ...googleapi.CallOption) (*ForwardingAddress, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &ForwardingAddress{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsForwardingAddressesDeleteCall struct { |
| s *Service |
| userId string |
| forwardingEmail string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Deletes the specified forwarding address and revokes any |
| // verification that may have been required. This method is only available to |
| // service account clients that have been delegated domain-wide authority. |
| // |
| // - forwardingEmail: The forwarding address to be deleted. |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsForwardingAddressesService) Delete(userId string, forwardingEmail string) *UsersSettingsForwardingAddressesDeleteCall { |
| c := &UsersSettingsForwardingAddressesDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.forwardingEmail = forwardingEmail |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsForwardingAddressesDeleteCall) Fields(s ...googleapi.Field) *UsersSettingsForwardingAddressesDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsForwardingAddressesDeleteCall) Context(ctx context.Context) *UsersSettingsForwardingAddressesDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsForwardingAddressesDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsForwardingAddressesDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/forwardingAddresses/{forwardingEmail}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("DELETE", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "forwardingEmail": c.forwardingEmail, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.forwardingAddresses.delete" call. |
| func (c *UsersSettingsForwardingAddressesDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return gensupport.WrapError(err) |
| } |
| return nil |
| } |
| |
| type UsersSettingsForwardingAddressesGetCall struct { |
| s *Service |
| userId string |
| forwardingEmail string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Gets the specified forwarding address. |
| // |
| // - forwardingEmail: The forwarding address to be retrieved. |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsForwardingAddressesService) Get(userId string, forwardingEmail string) *UsersSettingsForwardingAddressesGetCall { |
| c := &UsersSettingsForwardingAddressesGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.forwardingEmail = forwardingEmail |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsForwardingAddressesGetCall) Fields(s ...googleapi.Field) *UsersSettingsForwardingAddressesGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersSettingsForwardingAddressesGetCall) IfNoneMatch(entityTag string) *UsersSettingsForwardingAddressesGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsForwardingAddressesGetCall) Context(ctx context.Context) *UsersSettingsForwardingAddressesGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsForwardingAddressesGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsForwardingAddressesGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/forwardingAddresses/{forwardingEmail}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "forwardingEmail": c.forwardingEmail, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.forwardingAddresses.get" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *ForwardingAddress.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified was |
| // returned. |
| func (c *UsersSettingsForwardingAddressesGetCall) Do(opts ...googleapi.CallOption) (*ForwardingAddress, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &ForwardingAddress{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsForwardingAddressesListCall struct { |
| s *Service |
| userId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Lists the forwarding addresses for the specified account. |
| // |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsForwardingAddressesService) List(userId string) *UsersSettingsForwardingAddressesListCall { |
| c := &UsersSettingsForwardingAddressesListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsForwardingAddressesListCall) Fields(s ...googleapi.Field) *UsersSettingsForwardingAddressesListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersSettingsForwardingAddressesListCall) IfNoneMatch(entityTag string) *UsersSettingsForwardingAddressesListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsForwardingAddressesListCall) Context(ctx context.Context) *UsersSettingsForwardingAddressesListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsForwardingAddressesListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsForwardingAddressesListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/forwardingAddresses") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.forwardingAddresses.list" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *ListForwardingAddressesResponse.ServerResponse.Header or (if a response was |
| // returned at all) in error.(*googleapi.Error).Header. Use |
| // googleapi.IsNotModified to check whether the returned error was because |
| // http.StatusNotModified was returned. |
| func (c *UsersSettingsForwardingAddressesListCall) Do(opts ...googleapi.CallOption) (*ListForwardingAddressesResponse, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &ListForwardingAddressesResponse{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsSendAsCreateCall struct { |
| s *Service |
| userId string |
| sendas *SendAs |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Create: Creates a custom "from" send-as alias. If an SMTP MSA is specified, |
| // Gmail will attempt to connect to the SMTP service to validate the |
| // configuration before creating the alias. If ownership verification is |
| // required for the alias, a message will be sent to the email address and the |
| // resource's verification status will be set to `pending`; otherwise, the |
| // resource will be created with verification status set to `accepted`. If a |
| // signature is provided, Gmail will sanitize the HTML before saving it with |
| // the alias. This method is only available to service account clients that |
| // have been delegated domain-wide authority. |
| // |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsSendAsService) Create(userId string, sendas *SendAs) *UsersSettingsSendAsCreateCall { |
| c := &UsersSettingsSendAsCreateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.sendas = sendas |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsSendAsCreateCall) Fields(s ...googleapi.Field) *UsersSettingsSendAsCreateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsSendAsCreateCall) Context(ctx context.Context) *UsersSettingsSendAsCreateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsSendAsCreateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsSendAsCreateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.sendas) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/sendAs") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.sendAs.create" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *SendAs.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersSettingsSendAsCreateCall) Do(opts ...googleapi.CallOption) (*SendAs, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &SendAs{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsSendAsDeleteCall struct { |
| s *Service |
| userId string |
| sendAsEmail string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Deletes the specified send-as alias. Revokes any verification that |
| // may have been required for using it. This method is only available to |
| // service account clients that have been delegated domain-wide authority. |
| // |
| // - sendAsEmail: The send-as alias to be deleted. |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsSendAsService) Delete(userId string, sendAsEmail string) *UsersSettingsSendAsDeleteCall { |
| c := &UsersSettingsSendAsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.sendAsEmail = sendAsEmail |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsSendAsDeleteCall) Fields(s ...googleapi.Field) *UsersSettingsSendAsDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsSendAsDeleteCall) Context(ctx context.Context) *UsersSettingsSendAsDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsSendAsDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsSendAsDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/sendAs/{sendAsEmail}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("DELETE", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "sendAsEmail": c.sendAsEmail, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.sendAs.delete" call. |
| func (c *UsersSettingsSendAsDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return gensupport.WrapError(err) |
| } |
| return nil |
| } |
| |
| type UsersSettingsSendAsGetCall struct { |
| s *Service |
| userId string |
| sendAsEmail string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Gets the specified send-as alias. Fails with an HTTP 404 error if the |
| // specified address is not a member of the collection. |
| // |
| // - sendAsEmail: The send-as alias to be retrieved. |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsSendAsService) Get(userId string, sendAsEmail string) *UsersSettingsSendAsGetCall { |
| c := &UsersSettingsSendAsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.sendAsEmail = sendAsEmail |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsSendAsGetCall) Fields(s ...googleapi.Field) *UsersSettingsSendAsGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersSettingsSendAsGetCall) IfNoneMatch(entityTag string) *UsersSettingsSendAsGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsSendAsGetCall) Context(ctx context.Context) *UsersSettingsSendAsGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsSendAsGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsSendAsGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/sendAs/{sendAsEmail}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "sendAsEmail": c.sendAsEmail, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.sendAs.get" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *SendAs.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersSettingsSendAsGetCall) Do(opts ...googleapi.CallOption) (*SendAs, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &SendAs{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsSendAsListCall struct { |
| s *Service |
| userId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Lists the send-as aliases for the specified account. The result |
| // includes the primary send-as address associated with the account as well as |
| // any custom "from" aliases. |
| // |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsSendAsService) List(userId string) *UsersSettingsSendAsListCall { |
| c := &UsersSettingsSendAsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsSendAsListCall) Fields(s ...googleapi.Field) *UsersSettingsSendAsListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersSettingsSendAsListCall) IfNoneMatch(entityTag string) *UsersSettingsSendAsListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsSendAsListCall) Context(ctx context.Context) *UsersSettingsSendAsListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsSendAsListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsSendAsListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/sendAs") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.sendAs.list" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *ListSendAsResponse.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified was |
| // returned. |
| func (c *UsersSettingsSendAsListCall) Do(opts ...googleapi.CallOption) (*ListSendAsResponse, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &ListSendAsResponse{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsSendAsPatchCall struct { |
| s *Service |
| userId string |
| sendAsEmail string |
| sendas *SendAs |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Patch: Patch the specified send-as alias. |
| // |
| // - sendAsEmail: The send-as alias to be updated. |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsSendAsService) Patch(userId string, sendAsEmail string, sendas *SendAs) *UsersSettingsSendAsPatchCall { |
| c := &UsersSettingsSendAsPatchCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.sendAsEmail = sendAsEmail |
| c.sendas = sendas |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsSendAsPatchCall) Fields(s ...googleapi.Field) *UsersSettingsSendAsPatchCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsSendAsPatchCall) Context(ctx context.Context) *UsersSettingsSendAsPatchCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsSendAsPatchCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsSendAsPatchCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.sendas) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/sendAs/{sendAsEmail}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("PATCH", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "sendAsEmail": c.sendAsEmail, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.sendAs.patch" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *SendAs.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersSettingsSendAsPatchCall) Do(opts ...googleapi.CallOption) (*SendAs, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &SendAs{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsSendAsUpdateCall struct { |
| s *Service |
| userId string |
| sendAsEmail string |
| sendas *SendAs |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Update: Updates a send-as alias. If a signature is provided, Gmail will |
| // sanitize the HTML before saving it with the alias. Addresses other than the |
| // primary address for the account can only be updated by service account |
| // clients that have been delegated domain-wide authority. |
| // |
| // - sendAsEmail: The send-as alias to be updated. |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsSendAsService) Update(userId string, sendAsEmail string, sendas *SendAs) *UsersSettingsSendAsUpdateCall { |
| c := &UsersSettingsSendAsUpdateCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.sendAsEmail = sendAsEmail |
| c.sendas = sendas |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsSendAsUpdateCall) Fields(s ...googleapi.Field) *UsersSettingsSendAsUpdateCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsSendAsUpdateCall) Context(ctx context.Context) *UsersSettingsSendAsUpdateCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsSendAsUpdateCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsSendAsUpdateCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.sendas) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/sendAs/{sendAsEmail}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("PUT", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "sendAsEmail": c.sendAsEmail, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.sendAs.update" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *SendAs.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersSettingsSendAsUpdateCall) Do(opts ...googleapi.CallOption) (*SendAs, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &SendAs{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsSendAsVerifyCall struct { |
| s *Service |
| userId string |
| sendAsEmail string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Verify: Sends a verification email to the specified send-as alias address. |
| // The verification status must be `pending`. This method is only available to |
| // service account clients that have been delegated domain-wide authority. |
| // |
| // - sendAsEmail: The send-as alias to be verified. |
| // - userId: User's email address. The special value "me" can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsSendAsService) Verify(userId string, sendAsEmail string) *UsersSettingsSendAsVerifyCall { |
| c := &UsersSettingsSendAsVerifyCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.sendAsEmail = sendAsEmail |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsSendAsVerifyCall) Fields(s ...googleapi.Field) *UsersSettingsSendAsVerifyCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsSendAsVerifyCall) Context(ctx context.Context) *UsersSettingsSendAsVerifyCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsSendAsVerifyCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsSendAsVerifyCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/sendAs/{sendAsEmail}/verify") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "sendAsEmail": c.sendAsEmail, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.sendAs.verify" call. |
| func (c *UsersSettingsSendAsVerifyCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return gensupport.WrapError(err) |
| } |
| return nil |
| } |
| |
| type UsersSettingsSendAsSmimeInfoDeleteCall struct { |
| s *Service |
| userId string |
| sendAsEmail string |
| id string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Deletes the specified S/MIME config for the specified send-as alias. |
| // |
| // - id: The immutable ID for the SmimeInfo. |
| // - sendAsEmail: The email address that appears in the "From:" header for mail |
| // sent using this alias. |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsSendAsSmimeInfoService) Delete(userId string, sendAsEmail string, id string) *UsersSettingsSendAsSmimeInfoDeleteCall { |
| c := &UsersSettingsSendAsSmimeInfoDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.sendAsEmail = sendAsEmail |
| c.id = id |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsSendAsSmimeInfoDeleteCall) Fields(s ...googleapi.Field) *UsersSettingsSendAsSmimeInfoDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsSendAsSmimeInfoDeleteCall) Context(ctx context.Context) *UsersSettingsSendAsSmimeInfoDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsSendAsSmimeInfoDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsSendAsSmimeInfoDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/sendAs/{sendAsEmail}/smimeInfo/{id}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("DELETE", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "sendAsEmail": c.sendAsEmail, |
| "id": c.id, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.sendAs.smimeInfo.delete" call. |
| func (c *UsersSettingsSendAsSmimeInfoDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return gensupport.WrapError(err) |
| } |
| return nil |
| } |
| |
| type UsersSettingsSendAsSmimeInfoGetCall struct { |
| s *Service |
| userId string |
| sendAsEmail string |
| id string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Gets the specified S/MIME config for the specified send-as alias. |
| // |
| // - id: The immutable ID for the SmimeInfo. |
| // - sendAsEmail: The email address that appears in the "From:" header for mail |
| // sent using this alias. |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsSendAsSmimeInfoService) Get(userId string, sendAsEmail string, id string) *UsersSettingsSendAsSmimeInfoGetCall { |
| c := &UsersSettingsSendAsSmimeInfoGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.sendAsEmail = sendAsEmail |
| c.id = id |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsSendAsSmimeInfoGetCall) Fields(s ...googleapi.Field) *UsersSettingsSendAsSmimeInfoGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersSettingsSendAsSmimeInfoGetCall) IfNoneMatch(entityTag string) *UsersSettingsSendAsSmimeInfoGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsSendAsSmimeInfoGetCall) Context(ctx context.Context) *UsersSettingsSendAsSmimeInfoGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsSendAsSmimeInfoGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsSendAsSmimeInfoGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/sendAs/{sendAsEmail}/smimeInfo/{id}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "sendAsEmail": c.sendAsEmail, |
| "id": c.id, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.sendAs.smimeInfo.get" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *SmimeInfo.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersSettingsSendAsSmimeInfoGetCall) Do(opts ...googleapi.CallOption) (*SmimeInfo, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &SmimeInfo{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsSendAsSmimeInfoInsertCall struct { |
| s *Service |
| userId string |
| sendAsEmail string |
| smimeinfo *SmimeInfo |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Insert: Insert (upload) the given S/MIME config for the specified send-as |
| // alias. Note that pkcs12 format is required for the key. |
| // |
| // - sendAsEmail: The email address that appears in the "From:" header for mail |
| // sent using this alias. |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsSendAsSmimeInfoService) Insert(userId string, sendAsEmail string, smimeinfo *SmimeInfo) *UsersSettingsSendAsSmimeInfoInsertCall { |
| c := &UsersSettingsSendAsSmimeInfoInsertCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.sendAsEmail = sendAsEmail |
| c.smimeinfo = smimeinfo |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsSendAsSmimeInfoInsertCall) Fields(s ...googleapi.Field) *UsersSettingsSendAsSmimeInfoInsertCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsSendAsSmimeInfoInsertCall) Context(ctx context.Context) *UsersSettingsSendAsSmimeInfoInsertCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsSendAsSmimeInfoInsertCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsSendAsSmimeInfoInsertCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.smimeinfo) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/sendAs/{sendAsEmail}/smimeInfo") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "sendAsEmail": c.sendAsEmail, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.sendAs.smimeInfo.insert" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *SmimeInfo.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersSettingsSendAsSmimeInfoInsertCall) Do(opts ...googleapi.CallOption) (*SmimeInfo, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &SmimeInfo{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsSendAsSmimeInfoListCall struct { |
| s *Service |
| userId string |
| sendAsEmail string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Lists S/MIME configs for the specified send-as alias. |
| // |
| // - sendAsEmail: The email address that appears in the "From:" header for mail |
| // sent using this alias. |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsSendAsSmimeInfoService) List(userId string, sendAsEmail string) *UsersSettingsSendAsSmimeInfoListCall { |
| c := &UsersSettingsSendAsSmimeInfoListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.sendAsEmail = sendAsEmail |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsSendAsSmimeInfoListCall) Fields(s ...googleapi.Field) *UsersSettingsSendAsSmimeInfoListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersSettingsSendAsSmimeInfoListCall) IfNoneMatch(entityTag string) *UsersSettingsSendAsSmimeInfoListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsSendAsSmimeInfoListCall) Context(ctx context.Context) *UsersSettingsSendAsSmimeInfoListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsSendAsSmimeInfoListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsSendAsSmimeInfoListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/sendAs/{sendAsEmail}/smimeInfo") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "sendAsEmail": c.sendAsEmail, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.sendAs.smimeInfo.list" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *ListSmimeInfoResponse.ServerResponse.Header or (if a response was returned |
| // at all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified was |
| // returned. |
| func (c *UsersSettingsSendAsSmimeInfoListCall) Do(opts ...googleapi.CallOption) (*ListSmimeInfoResponse, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &ListSmimeInfoResponse{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersSettingsSendAsSmimeInfoSetDefaultCall struct { |
| s *Service |
| userId string |
| sendAsEmail string |
| id string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // SetDefault: Sets the default S/MIME config for the specified send-as alias. |
| // |
| // - id: The immutable ID for the SmimeInfo. |
| // - sendAsEmail: The email address that appears in the "From:" header for mail |
| // sent using this alias. |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersSettingsSendAsSmimeInfoService) SetDefault(userId string, sendAsEmail string, id string) *UsersSettingsSendAsSmimeInfoSetDefaultCall { |
| c := &UsersSettingsSendAsSmimeInfoSetDefaultCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.sendAsEmail = sendAsEmail |
| c.id = id |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersSettingsSendAsSmimeInfoSetDefaultCall) Fields(s ...googleapi.Field) *UsersSettingsSendAsSmimeInfoSetDefaultCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersSettingsSendAsSmimeInfoSetDefaultCall) Context(ctx context.Context) *UsersSettingsSendAsSmimeInfoSetDefaultCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersSettingsSendAsSmimeInfoSetDefaultCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersSettingsSendAsSmimeInfoSetDefaultCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/settings/sendAs/{sendAsEmail}/smimeInfo/{id}/setDefault") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "sendAsEmail": c.sendAsEmail, |
| "id": c.id, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.settings.sendAs.smimeInfo.setDefault" call. |
| func (c *UsersSettingsSendAsSmimeInfoSetDefaultCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return gensupport.WrapError(err) |
| } |
| return nil |
| } |
| |
| type UsersThreadsDeleteCall struct { |
| s *Service |
| userId string |
| id string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Delete: Immediately and permanently deletes the specified thread. Any |
| // messages that belong to the thread are also deleted. This operation cannot |
| // be undone. Prefer `threads.trash` instead. |
| // |
| // - id: ID of the Thread to delete. |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersThreadsService) Delete(userId string, id string) *UsersThreadsDeleteCall { |
| c := &UsersThreadsDeleteCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.id = id |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersThreadsDeleteCall) Fields(s ...googleapi.Field) *UsersThreadsDeleteCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersThreadsDeleteCall) Context(ctx context.Context) *UsersThreadsDeleteCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersThreadsDeleteCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersThreadsDeleteCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/threads/{id}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("DELETE", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "id": c.id, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.threads.delete" call. |
| func (c *UsersThreadsDeleteCall) Do(opts ...googleapi.CallOption) error { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if err != nil { |
| return err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return gensupport.WrapError(err) |
| } |
| return nil |
| } |
| |
| type UsersThreadsGetCall struct { |
| s *Service |
| userId string |
| id string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Get: Gets the specified thread. |
| // |
| // - id: The ID of the thread to retrieve. |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersThreadsService) Get(userId string, id string) *UsersThreadsGetCall { |
| c := &UsersThreadsGetCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.id = id |
| return c |
| } |
| |
| // Format sets the optional parameter "format": The format to return the |
| // messages in. |
| // |
| // Possible values: |
| // |
| // "full" (default) - Returns the full email message data with body content |
| // |
| // parsed in the `payload` field; the `raw` field is not used. Format cannot be |
| // used when accessing the api using the gmail.metadata scope. |
| // |
| // "metadata" - Returns only email message IDs, labels, and email headers. |
| // "minimal" - Returns only email message IDs and labels; does not return the |
| // |
| // email headers, body, or payload. |
| func (c *UsersThreadsGetCall) Format(format string) *UsersThreadsGetCall { |
| c.urlParams_.Set("format", format) |
| return c |
| } |
| |
| // MetadataHeaders sets the optional parameter "metadataHeaders": When given |
| // and format is METADATA, only include headers specified. |
| func (c *UsersThreadsGetCall) MetadataHeaders(metadataHeaders ...string) *UsersThreadsGetCall { |
| c.urlParams_.SetMulti("metadataHeaders", append([]string{}, metadataHeaders...)) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersThreadsGetCall) Fields(s ...googleapi.Field) *UsersThreadsGetCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersThreadsGetCall) IfNoneMatch(entityTag string) *UsersThreadsGetCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersThreadsGetCall) Context(ctx context.Context) *UsersThreadsGetCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersThreadsGetCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersThreadsGetCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/threads/{id}") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "id": c.id, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.threads.get" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *Thread.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersThreadsGetCall) Do(opts ...googleapi.CallOption) (*Thread, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &Thread{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersThreadsListCall struct { |
| s *Service |
| userId string |
| urlParams_ gensupport.URLParams |
| ifNoneMatch_ string |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // List: Lists the threads in the user's mailbox. |
| // |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersThreadsService) List(userId string) *UsersThreadsListCall { |
| c := &UsersThreadsListCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| return c |
| } |
| |
| // IncludeSpamTrash sets the optional parameter "includeSpamTrash": Include |
| // threads from `SPAM` and `TRASH` in the results. |
| func (c *UsersThreadsListCall) IncludeSpamTrash(includeSpamTrash bool) *UsersThreadsListCall { |
| c.urlParams_.Set("includeSpamTrash", fmt.Sprint(includeSpamTrash)) |
| return c |
| } |
| |
| // LabelIds sets the optional parameter "labelIds": Only return threads with |
| // labels that match all of the specified label IDs. |
| func (c *UsersThreadsListCall) LabelIds(labelIds ...string) *UsersThreadsListCall { |
| c.urlParams_.SetMulti("labelIds", append([]string{}, labelIds...)) |
| return c |
| } |
| |
| // MaxResults sets the optional parameter "maxResults": Maximum number of |
| // threads to return. This field defaults to 100. The maximum allowed value for |
| // this field is 500. |
| func (c *UsersThreadsListCall) MaxResults(maxResults int64) *UsersThreadsListCall { |
| c.urlParams_.Set("maxResults", fmt.Sprint(maxResults)) |
| return c |
| } |
| |
| // PageToken sets the optional parameter "pageToken": Page token to retrieve a |
| // specific page of results in the list. |
| func (c *UsersThreadsListCall) PageToken(pageToken string) *UsersThreadsListCall { |
| c.urlParams_.Set("pageToken", pageToken) |
| return c |
| } |
| |
| // Q sets the optional parameter "q": Only return threads matching the |
| // specified query. Supports the same query format as the Gmail search box. For |
| // example, "from:someuser@example.com rfc822msgid: is:unread". Parameter |
| // cannot be used when accessing the api using the gmail.metadata scope. |
| func (c *UsersThreadsListCall) Q(q string) *UsersThreadsListCall { |
| c.urlParams_.Set("q", q) |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersThreadsListCall) Fields(s ...googleapi.Field) *UsersThreadsListCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // IfNoneMatch sets an 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. |
| func (c *UsersThreadsListCall) IfNoneMatch(entityTag string) *UsersThreadsListCall { |
| c.ifNoneMatch_ = entityTag |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersThreadsListCall) Context(ctx context.Context) *UsersThreadsListCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersThreadsListCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersThreadsListCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| if c.ifNoneMatch_ != "" { |
| reqHeaders.Set("If-None-Match", c.ifNoneMatch_) |
| } |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/threads") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("GET", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.threads.list" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *ListThreadsResponse.ServerResponse.Header or (if a response was returned at |
| // all) in error.(*googleapi.Error).Header. Use googleapi.IsNotModified to |
| // check whether the returned error was because http.StatusNotModified was |
| // returned. |
| func (c *UsersThreadsListCall) Do(opts ...googleapi.CallOption) (*ListThreadsResponse, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &ListThreadsResponse{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| // Pages invokes f for each page of results. |
| // A non-nil error returned from f will halt the iteration. |
| // The provided context supersedes any context provided to the Context method. |
| func (c *UsersThreadsListCall) Pages(ctx context.Context, f func(*ListThreadsResponse) error) error { |
| c.ctx_ = ctx |
| defer c.PageToken(c.urlParams_.Get("pageToken")) |
| for { |
| x, err := c.Do() |
| if err != nil { |
| return err |
| } |
| if err := f(x); err != nil { |
| return err |
| } |
| if x.NextPageToken == "" { |
| return nil |
| } |
| c.PageToken(x.NextPageToken) |
| } |
| } |
| |
| type UsersThreadsModifyCall struct { |
| s *Service |
| userId string |
| id string |
| modifythreadrequest *ModifyThreadRequest |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Modify: Modifies the labels applied to the thread. This applies to all |
| // messages in the thread. |
| // |
| // - id: The ID of the thread to modify. |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersThreadsService) Modify(userId string, id string, modifythreadrequest *ModifyThreadRequest) *UsersThreadsModifyCall { |
| c := &UsersThreadsModifyCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.id = id |
| c.modifythreadrequest = modifythreadrequest |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersThreadsModifyCall) Fields(s ...googleapi.Field) *UsersThreadsModifyCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersThreadsModifyCall) Context(ctx context.Context) *UsersThreadsModifyCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersThreadsModifyCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersThreadsModifyCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "application/json", c.header_) |
| var body io.Reader = nil |
| body, err := googleapi.WithoutDataWrapper.JSONReader(c.modifythreadrequest) |
| if err != nil { |
| return nil, err |
| } |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/threads/{id}/modify") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "id": c.id, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.threads.modify" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *Thread.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersThreadsModifyCall) Do(opts ...googleapi.CallOption) (*Thread, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &Thread{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersThreadsTrashCall struct { |
| s *Service |
| userId string |
| id string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Trash: Moves the specified thread to the trash. Any messages that belong to |
| // the thread are also moved to the trash. |
| // |
| // - id: The ID of the thread to Trash. |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersThreadsService) Trash(userId string, id string) *UsersThreadsTrashCall { |
| c := &UsersThreadsTrashCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.id = id |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersThreadsTrashCall) Fields(s ...googleapi.Field) *UsersThreadsTrashCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersThreadsTrashCall) Context(ctx context.Context) *UsersThreadsTrashCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersThreadsTrashCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersThreadsTrashCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/threads/{id}/trash") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "id": c.id, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.threads.trash" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *Thread.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersThreadsTrashCall) Do(opts ...googleapi.CallOption) (*Thread, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &Thread{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
| |
| type UsersThreadsUntrashCall struct { |
| s *Service |
| userId string |
| id string |
| urlParams_ gensupport.URLParams |
| ctx_ context.Context |
| header_ http.Header |
| } |
| |
| // Untrash: Removes the specified thread from the trash. Any messages that |
| // belong to the thread are also removed from the trash. |
| // |
| // - id: The ID of the thread to remove from Trash. |
| // - userId: The user's email address. The special value `me` can be used to |
| // indicate the authenticated user. |
| func (r *UsersThreadsService) Untrash(userId string, id string) *UsersThreadsUntrashCall { |
| c := &UsersThreadsUntrashCall{s: r.s, urlParams_: make(gensupport.URLParams)} |
| c.userId = userId |
| c.id = id |
| return c |
| } |
| |
| // Fields allows partial responses to be retrieved. See |
| // https://developers.google.com/gdata/docs/2.0/basics#PartialResponse for more |
| // details. |
| func (c *UsersThreadsUntrashCall) Fields(s ...googleapi.Field) *UsersThreadsUntrashCall { |
| c.urlParams_.Set("fields", googleapi.CombineFields(s)) |
| return c |
| } |
| |
| // Context sets the context to be used in this call's Do method. |
| func (c *UsersThreadsUntrashCall) Context(ctx context.Context) *UsersThreadsUntrashCall { |
| c.ctx_ = ctx |
| return c |
| } |
| |
| // Header returns a http.Header that can be modified by the caller to add |
| // headers to the request. |
| func (c *UsersThreadsUntrashCall) Header() http.Header { |
| if c.header_ == nil { |
| c.header_ = make(http.Header) |
| } |
| return c.header_ |
| } |
| |
| func (c *UsersThreadsUntrashCall) doRequest(alt string) (*http.Response, error) { |
| reqHeaders := gensupport.SetHeaders(c.s.userAgent(), "", c.header_) |
| var body io.Reader = nil |
| c.urlParams_.Set("alt", alt) |
| c.urlParams_.Set("prettyPrint", "false") |
| urls := googleapi.ResolveRelative(c.s.BasePath, "gmail/v1/users/{userId}/threads/{id}/untrash") |
| urls += "?" + c.urlParams_.Encode() |
| req, err := http.NewRequest("POST", urls, body) |
| if err != nil { |
| return nil, err |
| } |
| req.Header = reqHeaders |
| googleapi.Expand(req.URL, map[string]string{ |
| "userId": c.userId, |
| "id": c.id, |
| }) |
| return gensupport.SendRequest(c.ctx_, c.s.client, req) |
| } |
| |
| // Do executes the "gmail.users.threads.untrash" call. |
| // Any non-2xx status code is an error. Response headers are in either |
| // *Thread.ServerResponse.Header or (if a response was returned at all) in |
| // error.(*googleapi.Error).Header. Use googleapi.IsNotModified to check |
| // whether the returned error was because http.StatusNotModified was returned. |
| func (c *UsersThreadsUntrashCall) Do(opts ...googleapi.CallOption) (*Thread, error) { |
| gensupport.SetOptions(c.urlParams_, opts...) |
| res, err := c.doRequest("json") |
| if res != nil && res.StatusCode == http.StatusNotModified { |
| if res.Body != nil { |
| res.Body.Close() |
| } |
| return nil, gensupport.WrapError(&googleapi.Error{ |
| Code: res.StatusCode, |
| Header: res.Header, |
| }) |
| } |
| if err != nil { |
| return nil, err |
| } |
| defer googleapi.CloseBody(res) |
| if err := googleapi.CheckResponse(res); err != nil { |
| return nil, gensupport.WrapError(err) |
| } |
| ret := &Thread{ |
| ServerResponse: googleapi.ServerResponse{ |
| Header: res.Header, |
| HTTPStatusCode: res.StatusCode, |
| }, |
| } |
| target := &ret |
| if err := gensupport.DecodeResponse(target, res); err != nil { |
| return nil, err |
| } |
| return ret, nil |
| } |
