"""Generated service metadata."""

SERVICE = {'alias': 'keep',
 'api_name': 'keep',
 'version': 'v1',
 'title': 'Google Keep API',
 'description': 'The Google Keep API is used in an enterprise environment to manage Google Keep content and resolve '
                'issues identified by cloud security software.',
 'documentation_link': 'https://developers.google.com/workspace/keep/api',
 'root_url': 'https://keep.googleapis.com/',
 'base_url': 'https://keep.googleapis.com/',
 'service_path': '',
 'methods': [{'dotted_path': 'keep.media.download',
              'api_dotted_path': 'keep.media.download',
              'resource_path': 'media',
              'py_name': 'download',
              'api_name': 'download',
              'http_method': 'GET',
              'path': 'v1/{+name}',
              'flat_path': 'v1/notes/{notesId}/attachments/{attachmentsId}',
              'description': 'Gets an attachment. To download attachment media via REST requires the alt=media query '
                             'parameter. Returns a 400 bad request error if attachment media is not available in the '
                             'requested MIME type.',
              'path_params': [{'py_name': 'name',
                               'api_name': 'name',
                               'location': 'path',
                               'required': True,
                               'repeated': False,
                               'type': 'string',
                               'enum_values': [],
                               'description': 'Required. The name of the attachment.',
                               'default': None}],
              'query_params': [{'py_name': 'mime_type',
                                'api_name': 'mimeType',
                                'location': 'query',
                                'required': False,
                                'repeated': False,
                                'type': 'string',
                                'enum_values': [],
                                'description': 'The IANA MIME type format requested. The requested MIME type must be '
                                               'one specified in the attachment.mime_type. Required when downloading '
                                               'attachment media and ignored otherwise.',
                                'default': None}],
              'request_schema_ref': None,
              'response_schema_ref': 'Attachment',
              'scopes': ['https://www.googleapis.com/auth/keep', 'https://www.googleapis.com/auth/keep.readonly'],
              'supports_media_upload': False,
              'media_upload_path': None,
              'supports_media_download': True},
             {'dotted_path': 'keep.notes.create',
              'api_dotted_path': 'keep.notes.create',
              'resource_path': 'notes',
              'py_name': 'create',
              'api_name': 'create',
              'http_method': 'POST',
              'path': 'v1/notes',
              'flat_path': 'v1/notes',
              'description': 'Creates a new note.',
              'path_params': [],
              'query_params': [],
              'request_schema_ref': 'Note',
              'response_schema_ref': 'Note',
              'scopes': ['https://www.googleapis.com/auth/keep'],
              'supports_media_upload': False,
              'media_upload_path': None,
              'supports_media_download': False},
             {'dotted_path': 'keep.notes.delete',
              'api_dotted_path': 'keep.notes.delete',
              'resource_path': 'notes',
              'py_name': 'delete',
              'api_name': 'delete',
              'http_method': 'DELETE',
              'path': 'v1/{+name}',
              'flat_path': 'v1/notes/{notesId}',
              'description': 'Deletes a note. Caller must have the `OWNER` role on the note to delete. Deleting a note '
                             'removes the resource immediately and cannot be undone. Any collaborators will lose '
                             'access to the note.',
              'path_params': [{'py_name': 'name',
                               'api_name': 'name',
                               'location': 'path',
                               'required': True,
                               'repeated': False,
                               'type': 'string',
                               'enum_values': [],
                               'description': 'Required. Name of the note to delete.',
                               'default': None}],
              'query_params': [],
              'request_schema_ref': None,
              'response_schema_ref': 'Empty',
              'scopes': ['https://www.googleapis.com/auth/keep'],
              'supports_media_upload': False,
              'media_upload_path': None,
              'supports_media_download': False},
             {'dotted_path': 'keep.notes.get',
              'api_dotted_path': 'keep.notes.get',
              'resource_path': 'notes',
              'py_name': 'get',
              'api_name': 'get',
              'http_method': 'GET',
              'path': 'v1/{+name}',
              'flat_path': 'v1/notes/{notesId}',
              'description': 'Gets a note.',
              'path_params': [{'py_name': 'name',
                               'api_name': 'name',
                               'location': 'path',
                               'required': True,
                               'repeated': False,
                               'type': 'string',
                               'enum_values': [],
                               'description': 'Required. Name of the resource.',
                               'default': None}],
              'query_params': [],
              'request_schema_ref': None,
              'response_schema_ref': 'Note',
              'scopes': ['https://www.googleapis.com/auth/keep', 'https://www.googleapis.com/auth/keep.readonly'],
              'supports_media_upload': False,
              'media_upload_path': None,
              'supports_media_download': False},
             {'dotted_path': 'keep.notes.list',
              'api_dotted_path': 'keep.notes.list',
              'resource_path': 'notes',
              'py_name': 'list',
              'api_name': 'list',
              'http_method': 'GET',
              'path': 'v1/notes',
              'flat_path': 'v1/notes',
              'description': 'Lists notes. Every list call returns a page of results with `page_size` as the upper '
                             'bound of returned items. A `page_size` of zero allows the server to choose the upper '
                             'bound. The ListNotesResponse contains at most `page_size` entries. If there are more '
                             'things left to list, it provides a `next_page_token` value. (Page tokens are opaque '
                             "values.) To get the next page of results, copy the result's `next_page_token` into the "
                             "next request's `page_token`. Repeat until the `next_page_token` returned with a page of "
                             'results is empty. ListNotes return consistent results in the face of concurrent changes, '
                             'or signals that it cannot with an ABORTED error.',
              'path_params': [],
              'query_params': [{'py_name': 'filter',
                                'api_name': 'filter',
                                'location': 'query',
                                'required': False,
                                'repeated': False,
                                'type': 'string',
                                'enum_values': [],
                                'description': 'Filter for list results. If no filter is supplied, the `trashed` '
                                               'filter is applied by default. Valid fields to filter by are: '
                                               '`create_time`, `update_time`, `trash_time`, and `trashed`. Filter '
                                               'syntax follows the [Google AIP filtering spec](https://aip.dev/160).',
                                'default': None},
                               {'py_name': 'page_size',
                                'api_name': 'pageSize',
                                'location': 'query',
                                'required': False,
                                'repeated': False,
                                'type': 'integer',
                                'enum_values': [],
                                'description': 'The maximum number of results to return.',
                                'default': None},
                               {'py_name': 'page_token',
                                'api_name': 'pageToken',
                                'location': 'query',
                                'required': False,
                                'repeated': False,
                                'type': 'string',
                                'enum_values': [],
                                'description': "The previous page's `next_page_token` field.",
                                'default': None}],
              'request_schema_ref': None,
              'response_schema_ref': 'ListNotesResponse',
              'scopes': ['https://www.googleapis.com/auth/keep', 'https://www.googleapis.com/auth/keep.readonly'],
              'supports_media_upload': False,
              'media_upload_path': None,
              'supports_media_download': False},
             {'dotted_path': 'keep.notes.permissions.batch_create',
              'api_dotted_path': 'keep.notes.permissions.batchCreate',
              'resource_path': 'notes.permissions',
              'py_name': 'batch_create',
              'api_name': 'batchCreate',
              'http_method': 'POST',
              'path': 'v1/{+parent}/permissions:batchCreate',
              'flat_path': 'v1/notes/{notesId}/permissions:batchCreate',
              'description': 'Creates one or more permissions on the note. Only permissions with the `WRITER` role may '
                             'be created. If adding any permission fails, then the entire request fails and no changes '
                             'are made.',
              'path_params': [{'py_name': 'parent',
                               'api_name': 'parent',
                               'location': 'path',
                               'required': True,
                               'repeated': False,
                               'type': 'string',
                               'enum_values': [],
                               'description': 'The parent resource shared by all Permissions being created. Format: '
                                              '`notes/{note}` If this is set, the parent field in the CreatePermission '
                                              'messages must either be empty or match this field.',
                               'default': None}],
              'query_params': [],
              'request_schema_ref': 'BatchCreatePermissionsRequest',
              'response_schema_ref': 'BatchCreatePermissionsResponse',
              'scopes': ['https://www.googleapis.com/auth/keep'],
              'supports_media_upload': False,
              'media_upload_path': None,
              'supports_media_download': False},
             {'dotted_path': 'keep.notes.permissions.batch_delete',
              'api_dotted_path': 'keep.notes.permissions.batchDelete',
              'resource_path': 'notes.permissions',
              'py_name': 'batch_delete',
              'api_name': 'batchDelete',
              'http_method': 'POST',
              'path': 'v1/{+parent}/permissions:batchDelete',
              'flat_path': 'v1/notes/{notesId}/permissions:batchDelete',
              'description': 'Deletes one or more permissions on the note. The specified entities will immediately '
                             "lose access. A permission with the `OWNER` role can't be removed. If removing a "
                             'permission fails, then the entire request fails and no changes are made. Returns a 400 '
                             'bad request error if a specified permission does not exist on the note.',
              'path_params': [{'py_name': 'parent',
                               'api_name': 'parent',
                               'location': 'path',
                               'required': True,
                               'repeated': False,
                               'type': 'string',
                               'enum_values': [],
                               'description': 'The parent resource shared by all permissions being deleted. Format: '
                                              '`notes/{note}` If this is set, the parent of all of the permissions '
                                              'specified in the DeletePermissionRequest messages must match this '
                                              'field.',
                               'default': None}],
              'query_params': [],
              'request_schema_ref': 'BatchDeletePermissionsRequest',
              'response_schema_ref': 'Empty',
              'scopes': ['https://www.googleapis.com/auth/keep'],
              'supports_media_upload': False,
              'media_upload_path': None,
              'supports_media_download': False}],
 'schemas': {'Attachment': {'description': 'An attachment to a note.',
                            'id': 'Attachment',
                            'properties': {'mimeType': {'description': 'The MIME types (IANA media types) in which the '
                                                                       'attachment is available.',
                                                        'items': {'type': 'string'},
                                                        'type': 'array'},
                                           'name': {'description': 'The resource name;', 'type': 'string'}},
                            'type': 'object'},
             'BatchCreatePermissionsRequest': {'description': 'The request to add one or more permissions on the note. '
                                                              'Currently, only the `WRITER` role may be specified. If '
                                                              'adding a permission fails, then the entire request '
                                                              'fails and no changes are made.',
                                               'id': 'BatchCreatePermissionsRequest',
                                               'properties': {'requests': {'description': 'The request message '
                                                                                          'specifying the resources to '
                                                                                          'create.',
                                                                           'items': {'$ref': 'CreatePermissionRequest'},
                                                                           'type': 'array'}},
                                               'type': 'object'},
             'BatchCreatePermissionsResponse': {'description': 'The response for creating permissions on a note.',
                                                'id': 'BatchCreatePermissionsResponse',
                                                'properties': {'permissions': {'description': 'Permissions created.',
                                                                               'items': {'$ref': 'Permission'},
                                                                               'type': 'array'}},
                                                'type': 'object'},
             'BatchDeletePermissionsRequest': {'description': 'The request to remove one or more permissions from a '
                                                              "note. A permission with the `OWNER` role can't be "
                                                              'removed. If removing a permission fails, then the '
                                                              'entire request fails and no changes are made. Returns a '
                                                              '400 bad request error if a specified permission does '
                                                              'not exist on the note.',
                                               'id': 'BatchDeletePermissionsRequest',
                                               'properties': {'names': {'description': 'Required. The names of the '
                                                                                       'permissions to delete. Format: '
                                                                                       '`notes/{note}/permissions/{permission}`',
                                                                        'items': {'type': 'string'},
                                                                        'type': 'array'}},
                                               'type': 'object'},
             'CreatePermissionRequest': {'description': 'The request to add a single permission on the note.',
                                         'id': 'CreatePermissionRequest',
                                         'properties': {'parent': {'description': 'Required. The parent note where '
                                                                                  'this permission will be created. '
                                                                                  'Format: `notes/{note}`',
                                                                   'type': 'string'},
                                                        'permission': {'$ref': 'Permission',
                                                                       'description': 'Required. The permission to '
                                                                                      'create. One of '
                                                                                      'Permission.email, User.email or '
                                                                                      'Group.email must be supplied.'}},
                                         'type': 'object'},
             'Empty': {'description': 'A generic empty message that you can re-use to avoid defining duplicated empty '
                                      'messages in your APIs. A typical example is to use it as the request or the '
                                      'response type of an API method. For instance: service Foo { rpc '
                                      'Bar(google.protobuf.Empty) returns (google.protobuf.Empty); }',
                       'id': 'Empty',
                       'properties': {},
                       'type': 'object'},
             'Family': {'description': 'Describes a single Google Family.',
                        'id': 'Family',
                        'properties': {},
                        'type': 'object'},
             'Group': {'description': 'Describes a single Group.',
                       'id': 'Group',
                       'properties': {'email': {'description': 'The group email.', 'type': 'string'}},
                       'type': 'object'},
             'ListContent': {'description': 'The list of items for a single list note.',
                             'id': 'ListContent',
                             'properties': {'listItems': {'description': 'The items in the list. The number of items '
                                                                         'must be less than 1,000.',
                                                          'items': {'$ref': 'ListItem'},
                                                          'type': 'array'}},
                             'type': 'object'},
             'ListItem': {'description': "A single list item in a note's list.",
                          'id': 'ListItem',
                          'properties': {'checked': {'description': 'Whether this item has been checked off or not.',
                                                     'type': 'boolean'},
                                         'childListItems': {'description': 'If set, list of list items nested under '
                                                                           'this list item. Only one level of nesting '
                                                                           'is allowed.',
                                                            'items': {'$ref': 'ListItem'},
                                                            'type': 'array'},
                                         'text': {'$ref': 'TextContent',
                                                  'description': 'The text of this item. Length must be less than '
                                                                 '1,000 characters.'}},
                          'type': 'object'},
             'ListNotesResponse': {'description': 'The response when listing a page of notes.',
                                   'id': 'ListNotesResponse',
                                   'properties': {'nextPageToken': {'description': "Next page's `page_token` field.",
                                                                    'type': 'string'},
                                                  'notes': {'description': 'A page of notes.',
                                                            'items': {'$ref': 'Note'},
                                                            'type': 'array'}},
                                   'type': 'object'},
             'Note': {'description': 'A single note.',
                      'id': 'Note',
                      'properties': {'attachments': {'description': 'Output only. The attachments attached to this '
                                                                    'note.',
                                                     'items': {'$ref': 'Attachment'},
                                                     'readOnly': True,
                                                     'type': 'array'},
                                     'body': {'$ref': 'Section', 'description': 'The body of the note.'},
                                     'createTime': {'description': 'Output only. When this note was created.',
                                                    'format': 'google-datetime',
                                                    'readOnly': True,
                                                    'type': 'string'},
                                     'name': {'description': 'Output only. The resource name of this note. See general '
                                                             'note on identifiers in KeepService.',
                                              'readOnly': True,
                                              'type': 'string'},
                                     'permissions': {'description': 'Output only. The list of permissions set on the '
                                                                    'note. Contains at least one entry for the note '
                                                                    'owner.',
                                                     'items': {'$ref': 'Permission'},
                                                     'readOnly': True,
                                                     'type': 'array'},
                                     'title': {'description': 'The title of the note. Length must be less than 1,000 '
                                                              'characters.',
                                               'type': 'string'},
                                     'trashTime': {'description': 'Output only. When this note was trashed. If '
                                                                  '`trashed`, the note is eventually deleted. If the '
                                                                  'note is not trashed, this field is not set (and the '
                                                                  'trashed field is `false`).',
                                                   'format': 'google-datetime',
                                                   'readOnly': True,
                                                   'type': 'string'},
                                     'trashed': {'description': 'Output only. `true` if this note has been trashed. If '
                                                                'trashed, the note is eventually deleted.',
                                                 'readOnly': True,
                                                 'type': 'boolean'},
                                     'updateTime': {'description': 'Output only. When this note was last modified.',
                                                    'format': 'google-datetime',
                                                    'readOnly': True,
                                                    'type': 'string'}},
                      'type': 'object'},
             'Permission': {'description': 'A single permission on the note. Associates a `member` with a `role`.',
                            'id': 'Permission',
                            'properties': {'deleted': {'description': 'Output only. Whether this member has been '
                                                                      'deleted. If the member is recovered, this value '
                                                                      'is set to false and the recovered member '
                                                                      'retains the role on the note.',
                                                       'readOnly': True,
                                                       'type': 'boolean'},
                                           'email': {'description': 'The email associated with the member. If set on '
                                                                    'create, the `email` field in the `User` or '
                                                                    '`Group` message must either be empty or match '
                                                                    'this field. On read, may be unset if the member '
                                                                    'does not have an associated email.',
                                                     'type': 'string'},
                                           'family': {'$ref': 'Family',
                                                      'description': 'Output only. The Google Family to which this '
                                                                     'role applies.',
                                                      'readOnly': True},
                                           'group': {'$ref': 'Group',
                                                     'description': 'Output only. The group to which this role '
                                                                    'applies.',
                                                     'readOnly': True},
                                           'name': {'description': 'Output only. The resource name.',
                                                    'readOnly': True,
                                                    'type': 'string'},
                                           'role': {'description': 'The role granted by this permission. The role '
                                                                   'determines the entity’s ability to read, write, '
                                                                   'and share notes.',
                                                    'enum': ['ROLE_UNSPECIFIED', 'OWNER', 'WRITER'],
                                                    'enumDescriptions': ['An undefined role.',
                                                                         'A role granting full access. This role '
                                                                         'cannot be added or removed. Defined by the '
                                                                         'creator of the note.',
                                                                         'A role granting the ability to contribute '
                                                                         'content and modify note permissions.'],
                                                    'type': 'string'},
                                           'user': {'$ref': 'User',
                                                    'description': 'Output only. The user to whom this role applies.',
                                                    'readOnly': True}},
                            'type': 'object'},
             'Section': {'description': 'The content of the note.',
                         'id': 'Section',
                         'properties': {'list': {'$ref': 'ListContent',
                                                 'description': "Used if this section's content is a list."},
                                        'text': {'$ref': 'TextContent',
                                                 'description': "Used if this section's content is a block of text. "
                                                                'The length of the text content must be less than '
                                                                '20,000 characters.'}},
                         'type': 'object'},
             'TextContent': {'description': 'The block of text for a single text section or list item.',
                             'id': 'TextContent',
                             'properties': {'text': {'description': 'The text of the note. The limits on this vary '
                                                                    'with the specific field using this type.',
                                                     'type': 'string'}},
                             'type': 'object'},
             'User': {'description': 'Describes a single user.',
                      'id': 'User',
                      'properties': {'email': {'description': "The user's email.", 'type': 'string'}},
                      'type': 'object'}},
 'auth_scopes': {'https://www.googleapis.com/auth/keep': 'See, edit, create and permanently delete all your Google '
                                                         'Keep data',
                 'https://www.googleapis.com/auth/keep.readonly': 'View all your Google Keep data'}}
