| // This is a generated file (see the discoveryapis_generator project). |
| |
| // ignore_for_file: camel_case_types |
| // ignore_for_file: comment_references |
| // ignore_for_file: file_names |
| // ignore_for_file: library_names |
| // ignore_for_file: lines_longer_than_80_chars |
| // ignore_for_file: non_constant_identifier_names |
| // ignore_for_file: prefer_expression_function_bodies |
| // ignore_for_file: prefer_interpolation_to_compose_strings |
| // ignore_for_file: unnecessary_brace_in_string_interps |
| // ignore_for_file: unnecessary_lambdas |
| // ignore_for_file: unnecessary_string_interpolations |
| |
| /// Google Forms API - v1 |
| /// |
| /// Reads and writes Google Forms and responses. |
| /// |
| /// For more information, see <https://developers.google.com/forms/api> |
| /// |
| /// Create an instance of [FormsApi] to access these resources: |
| /// |
| /// - [FormsResource] |
| /// - [FormsResponsesResource] |
| /// - [FormsWatchesResource] |
| library forms.v1; |
| |
| import 'dart:async' as async; |
| import 'dart:convert' as convert; |
| import 'dart:core' as core; |
| |
| import 'package:_discoveryapis_commons/_discoveryapis_commons.dart' as commons; |
| import 'package:http/http.dart' as http; |
| |
| // ignore: deprecated_member_use_from_same_package |
| import '../shared.dart'; |
| import '../src/user_agent.dart'; |
| |
| export 'package:_discoveryapis_commons/_discoveryapis_commons.dart' |
| show ApiRequestError, DetailedApiRequestError; |
| |
| /// Reads and writes Google Forms and responses. |
| class FormsApi { |
| /// See, edit, create, and delete all of your Google Drive files |
| static const driveScope = 'https://www.googleapis.com/auth/drive'; |
| |
| /// See, edit, create, and delete only the specific Google Drive files you use |
| /// with this app |
| static const driveFileScope = 'https://www.googleapis.com/auth/drive.file'; |
| |
| /// See and download all your Google Drive files |
| static const driveReadonlyScope = |
| 'https://www.googleapis.com/auth/drive.readonly'; |
| |
| /// See, edit, create, and delete all your Google Forms forms |
| static const formsBodyScope = 'https://www.googleapis.com/auth/forms.body'; |
| |
| /// See all your Google Forms forms |
| static const formsBodyReadonlyScope = |
| 'https://www.googleapis.com/auth/forms.body.readonly'; |
| |
| /// See all responses to your Google Forms forms |
| static const formsResponsesReadonlyScope = |
| 'https://www.googleapis.com/auth/forms.responses.readonly'; |
| |
| final commons.ApiRequester _requester; |
| |
| FormsResource get forms => FormsResource(_requester); |
| |
| FormsApi(http.Client client, |
| {core.String rootUrl = 'https://forms.googleapis.com/', |
| core.String servicePath = ''}) |
| : _requester = |
| commons.ApiRequester(client, rootUrl, servicePath, requestHeaders); |
| } |
| |
| class FormsResource { |
| final commons.ApiRequester _requester; |
| |
| FormsResponsesResource get responses => FormsResponsesResource(_requester); |
| FormsWatchesResource get watches => FormsWatchesResource(_requester); |
| |
| FormsResource(commons.ApiRequester client) : _requester = client; |
| |
| /// Change the form with a batch of updates. |
| /// |
| /// [request] - The metadata request object. |
| /// |
| /// Request parameters: |
| /// |
| /// [formId] - Required. The form ID. |
| /// |
| /// [$fields] - Selector specifying which fields to include in a partial |
| /// response. |
| /// |
| /// Completes with a [BatchUpdateFormResponse]. |
| /// |
| /// Completes with a [commons.ApiRequestError] if the API endpoint returned an |
| /// error. |
| /// |
| /// If the used [http.Client] completes with an error when making a REST call, |
| /// this method will complete with the same error. |
| async.Future<BatchUpdateFormResponse> batchUpdate( |
| BatchUpdateFormRequest request, |
| core.String formId, { |
| core.String? $fields, |
| }) async { |
| final body_ = convert.json.encode(request); |
| final queryParams_ = <core.String, core.List<core.String>>{ |
| if ($fields != null) 'fields': [$fields], |
| }; |
| |
| final url_ = |
| 'v1/forms/' + commons.escapeVariable('$formId') + ':batchUpdate'; |
| |
| final response_ = await _requester.request( |
| url_, |
| 'POST', |
| body: body_, |
| queryParams: queryParams_, |
| ); |
| return BatchUpdateFormResponse.fromJson( |
| response_ as core.Map<core.String, core.dynamic>); |
| } |
| |
| /// Create a new form using the title given in the provided form message in |
| /// the request. |
| /// |
| /// *Important:* Only the form.info.title and form.info.document_title fields |
| /// are copied to the new form. All other fields including the form |
| /// description, items and settings are disallowed. To create a new form and |
| /// add items, you must first call forms.create to create an empty form with a |
| /// title and (optional) document title, and then call forms.update to add the |
| /// items. |
| /// |
| /// [request] - The metadata request object. |
| /// |
| /// Request parameters: |
| /// |
| /// [$fields] - Selector specifying which fields to include in a partial |
| /// response. |
| /// |
| /// Completes with a [Form]. |
| /// |
| /// Completes with a [commons.ApiRequestError] if the API endpoint returned an |
| /// error. |
| /// |
| /// If the used [http.Client] completes with an error when making a REST call, |
| /// this method will complete with the same error. |
| async.Future<Form> create( |
| Form request, { |
| core.String? $fields, |
| }) async { |
| final body_ = convert.json.encode(request); |
| final queryParams_ = <core.String, core.List<core.String>>{ |
| if ($fields != null) 'fields': [$fields], |
| }; |
| |
| const url_ = 'v1/forms'; |
| |
| final response_ = await _requester.request( |
| url_, |
| 'POST', |
| body: body_, |
| queryParams: queryParams_, |
| ); |
| return Form.fromJson(response_ as core.Map<core.String, core.dynamic>); |
| } |
| |
| /// Get a form. |
| /// |
| /// Request parameters: |
| /// |
| /// [formId] - Required. The form ID. |
| /// |
| /// [$fields] - Selector specifying which fields to include in a partial |
| /// response. |
| /// |
| /// Completes with a [Form]. |
| /// |
| /// Completes with a [commons.ApiRequestError] if the API endpoint returned an |
| /// error. |
| /// |
| /// If the used [http.Client] completes with an error when making a REST call, |
| /// this method will complete with the same error. |
| async.Future<Form> get( |
| core.String formId, { |
| core.String? $fields, |
| }) async { |
| final queryParams_ = <core.String, core.List<core.String>>{ |
| if ($fields != null) 'fields': [$fields], |
| }; |
| |
| final url_ = 'v1/forms/' + commons.escapeVariable('$formId'); |
| |
| final response_ = await _requester.request( |
| url_, |
| 'GET', |
| queryParams: queryParams_, |
| ); |
| return Form.fromJson(response_ as core.Map<core.String, core.dynamic>); |
| } |
| } |
| |
| class FormsResponsesResource { |
| final commons.ApiRequester _requester; |
| |
| FormsResponsesResource(commons.ApiRequester client) : _requester = client; |
| |
| /// Get one response from the form. |
| /// |
| /// Request parameters: |
| /// |
| /// [formId] - Required. The form ID. |
| /// |
| /// [responseId] - Required. The response ID within the form. |
| /// |
| /// [$fields] - Selector specifying which fields to include in a partial |
| /// response. |
| /// |
| /// Completes with a [FormResponse]. |
| /// |
| /// Completes with a [commons.ApiRequestError] if the API endpoint returned an |
| /// error. |
| /// |
| /// If the used [http.Client] completes with an error when making a REST call, |
| /// this method will complete with the same error. |
| async.Future<FormResponse> get( |
| core.String formId, |
| core.String responseId, { |
| core.String? $fields, |
| }) async { |
| final queryParams_ = <core.String, core.List<core.String>>{ |
| if ($fields != null) 'fields': [$fields], |
| }; |
| |
| final url_ = 'v1/forms/' + |
| commons.escapeVariable('$formId') + |
| '/responses/' + |
| commons.escapeVariable('$responseId'); |
| |
| final response_ = await _requester.request( |
| url_, |
| 'GET', |
| queryParams: queryParams_, |
| ); |
| return FormResponse.fromJson( |
| response_ as core.Map<core.String, core.dynamic>); |
| } |
| |
| /// List a form's responses. |
| /// |
| /// Request parameters: |
| /// |
| /// [formId] - Required. ID of the Form whose responses to list. |
| /// |
| /// [filter] - Which form responses to return. Currently, the only supported |
| /// filters are: * timestamp \> *N* which means to get all form responses |
| /// submitted after (but not at) timestamp *N*. * timestamp \>= *N* which |
| /// means to get all form responses submitted at and after timestamp *N*. For |
| /// both supported filters, timestamp must be formatted in RFC3339 UTC "Zulu" |
| /// format. Examples: "2014-10-02T15:01:23Z" and |
| /// "2014-10-02T15:01:23.045123456Z". |
| /// |
| /// [pageSize] - The maximum number of responses to return. The service may |
| /// return fewer than this value. If unspecified or zero, at most 5000 |
| /// responses are returned. |
| /// |
| /// [pageToken] - A page token returned by a previous list response. If this |
| /// field is set, the form and the values of the filter must be the same as |
| /// for the original request. |
| /// |
| /// [$fields] - Selector specifying which fields to include in a partial |
| /// response. |
| /// |
| /// Completes with a [ListFormResponsesResponse]. |
| /// |
| /// Completes with a [commons.ApiRequestError] if the API endpoint returned an |
| /// error. |
| /// |
| /// If the used [http.Client] completes with an error when making a REST call, |
| /// this method will complete with the same error. |
| async.Future<ListFormResponsesResponse> list( |
| core.String formId, { |
| core.String? filter, |
| core.int? pageSize, |
| core.String? pageToken, |
| core.String? $fields, |
| }) async { |
| final queryParams_ = <core.String, core.List<core.String>>{ |
| if (filter != null) 'filter': [filter], |
| if (pageSize != null) 'pageSize': ['${pageSize}'], |
| if (pageToken != null) 'pageToken': [pageToken], |
| if ($fields != null) 'fields': [$fields], |
| }; |
| |
| final url_ = 'v1/forms/' + commons.escapeVariable('$formId') + '/responses'; |
| |
| final response_ = await _requester.request( |
| url_, |
| 'GET', |
| queryParams: queryParams_, |
| ); |
| return ListFormResponsesResponse.fromJson( |
| response_ as core.Map<core.String, core.dynamic>); |
| } |
| } |
| |
| class FormsWatchesResource { |
| final commons.ApiRequester _requester; |
| |
| FormsWatchesResource(commons.ApiRequester client) : _requester = client; |
| |
| /// Create a new watch. |
| /// |
| /// If a watch ID is provided, it must be unused. For each invoking project, |
| /// the per form limit is one watch per Watch.EventType. A watch expires seven |
| /// days after it is created (see Watch.expire_time). |
| /// |
| /// [request] - The metadata request object. |
| /// |
| /// Request parameters: |
| /// |
| /// [formId] - Required. ID of the Form to watch. |
| /// |
| /// [$fields] - Selector specifying which fields to include in a partial |
| /// response. |
| /// |
| /// Completes with a [Watch]. |
| /// |
| /// Completes with a [commons.ApiRequestError] if the API endpoint returned an |
| /// error. |
| /// |
| /// If the used [http.Client] completes with an error when making a REST call, |
| /// this method will complete with the same error. |
| async.Future<Watch> create( |
| CreateWatchRequest request, |
| core.String formId, { |
| core.String? $fields, |
| }) async { |
| final body_ = convert.json.encode(request); |
| final queryParams_ = <core.String, core.List<core.String>>{ |
| if ($fields != null) 'fields': [$fields], |
| }; |
| |
| final url_ = 'v1/forms/' + commons.escapeVariable('$formId') + '/watches'; |
| |
| final response_ = await _requester.request( |
| url_, |
| 'POST', |
| body: body_, |
| queryParams: queryParams_, |
| ); |
| return Watch.fromJson(response_ as core.Map<core.String, core.dynamic>); |
| } |
| |
| /// Delete a watch. |
| /// |
| /// Request parameters: |
| /// |
| /// [formId] - Required. The ID of the Form. |
| /// |
| /// [watchId] - Required. The ID of the Watch to delete. |
| /// |
| /// [$fields] - Selector specifying which fields to include in a partial |
| /// response. |
| /// |
| /// Completes with a [Empty]. |
| /// |
| /// Completes with a [commons.ApiRequestError] if the API endpoint returned an |
| /// error. |
| /// |
| /// If the used [http.Client] completes with an error when making a REST call, |
| /// this method will complete with the same error. |
| async.Future<Empty> delete( |
| core.String formId, |
| core.String watchId, { |
| core.String? $fields, |
| }) async { |
| final queryParams_ = <core.String, core.List<core.String>>{ |
| if ($fields != null) 'fields': [$fields], |
| }; |
| |
| final url_ = 'v1/forms/' + |
| commons.escapeVariable('$formId') + |
| '/watches/' + |
| commons.escapeVariable('$watchId'); |
| |
| final response_ = await _requester.request( |
| url_, |
| 'DELETE', |
| queryParams: queryParams_, |
| ); |
| return Empty.fromJson(response_ as core.Map<core.String, core.dynamic>); |
| } |
| |
| /// Return a list of the watches owned by the invoking project. |
| /// |
| /// The maximum number of watches is two: For each invoker, the limit is one |
| /// for each event type per form. |
| /// |
| /// Request parameters: |
| /// |
| /// [formId] - Required. ID of the Form whose watches to list. |
| /// |
| /// [$fields] - Selector specifying which fields to include in a partial |
| /// response. |
| /// |
| /// Completes with a [ListWatchesResponse]. |
| /// |
| /// Completes with a [commons.ApiRequestError] if the API endpoint returned an |
| /// error. |
| /// |
| /// If the used [http.Client] completes with an error when making a REST call, |
| /// this method will complete with the same error. |
| async.Future<ListWatchesResponse> list( |
| core.String formId, { |
| core.String? $fields, |
| }) async { |
| final queryParams_ = <core.String, core.List<core.String>>{ |
| if ($fields != null) 'fields': [$fields], |
| }; |
| |
| final url_ = 'v1/forms/' + commons.escapeVariable('$formId') + '/watches'; |
| |
| final response_ = await _requester.request( |
| url_, |
| 'GET', |
| queryParams: queryParams_, |
| ); |
| return ListWatchesResponse.fromJson( |
| response_ as core.Map<core.String, core.dynamic>); |
| } |
| |
| /// Renew an existing watch for seven days. |
| /// |
| /// The state of the watch after renewal is `ACTIVE`, and the `expire_time` is |
| /// seven days from the renewal. Renewing a watch in an error state (e.g. |
| /// `SUSPENDED`) succeeds if the error is no longer present, but fail |
| /// otherwise. After a watch has expired, RenewWatch returns `NOT_FOUND`. |
| /// |
| /// [request] - The metadata request object. |
| /// |
| /// Request parameters: |
| /// |
| /// [formId] - Required. The ID of the Form. |
| /// |
| /// [watchId] - Required. The ID of the Watch to renew. |
| /// |
| /// [$fields] - Selector specifying which fields to include in a partial |
| /// response. |
| /// |
| /// Completes with a [Watch]. |
| /// |
| /// Completes with a [commons.ApiRequestError] if the API endpoint returned an |
| /// error. |
| /// |
| /// If the used [http.Client] completes with an error when making a REST call, |
| /// this method will complete with the same error. |
| async.Future<Watch> renew( |
| RenewWatchRequest request, |
| core.String formId, |
| core.String watchId, { |
| core.String? $fields, |
| }) async { |
| final body_ = convert.json.encode(request); |
| final queryParams_ = <core.String, core.List<core.String>>{ |
| if ($fields != null) 'fields': [$fields], |
| }; |
| |
| final url_ = 'v1/forms/' + |
| commons.escapeVariable('$formId') + |
| '/watches/' + |
| commons.escapeVariable('$watchId') + |
| ':renew'; |
| |
| final response_ = await _requester.request( |
| url_, |
| 'POST', |
| body: body_, |
| queryParams: queryParams_, |
| ); |
| return Watch.fromJson(response_ as core.Map<core.String, core.dynamic>); |
| } |
| } |
| |
| /// The submitted answer for a question. |
| class Answer { |
| /// The answers to a file upload question. |
| /// |
| /// Output only. |
| FileUploadAnswers? fileUploadAnswers; |
| |
| /// The grade for the answer if the form was a quiz. |
| /// |
| /// Output only. |
| Grade? grade; |
| |
| /// The question's ID. |
| /// |
| /// See also Question.question_id. |
| /// |
| /// Output only. |
| core.String? questionId; |
| |
| /// The specific answers as text. |
| /// |
| /// Output only. |
| TextAnswers? textAnswers; |
| |
| Answer({ |
| this.fileUploadAnswers, |
| this.grade, |
| this.questionId, |
| this.textAnswers, |
| }); |
| |
| Answer.fromJson(core.Map json_) |
| : this( |
| fileUploadAnswers: json_.containsKey('fileUploadAnswers') |
| ? FileUploadAnswers.fromJson(json_['fileUploadAnswers'] |
| as core.Map<core.String, core.dynamic>) |
| : null, |
| grade: json_.containsKey('grade') |
| ? Grade.fromJson( |
| json_['grade'] as core.Map<core.String, core.dynamic>) |
| : null, |
| questionId: json_.containsKey('questionId') |
| ? json_['questionId'] as core.String |
| : null, |
| textAnswers: json_.containsKey('textAnswers') |
| ? TextAnswers.fromJson( |
| json_['textAnswers'] as core.Map<core.String, core.dynamic>) |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (fileUploadAnswers != null) 'fileUploadAnswers': fileUploadAnswers!, |
| if (grade != null) 'grade': grade!, |
| if (questionId != null) 'questionId': questionId!, |
| if (textAnswers != null) 'textAnswers': textAnswers!, |
| }; |
| } |
| |
| /// A batch of updates to perform on a form. |
| /// |
| /// All the specified updates are made or none of them are. |
| class BatchUpdateFormRequest { |
| /// Whether to return an updated version of the model in the response. |
| core.bool? includeFormInResponse; |
| |
| /// The update requests of this batch. |
| /// |
| /// Required. |
| core.List<Request>? requests; |
| |
| /// Provides control over how write requests are executed. |
| WriteControl? writeControl; |
| |
| BatchUpdateFormRequest({ |
| this.includeFormInResponse, |
| this.requests, |
| this.writeControl, |
| }); |
| |
| BatchUpdateFormRequest.fromJson(core.Map json_) |
| : this( |
| includeFormInResponse: json_.containsKey('includeFormInResponse') |
| ? json_['includeFormInResponse'] as core.bool |
| : null, |
| requests: json_.containsKey('requests') |
| ? (json_['requests'] as core.List) |
| .map((value) => Request.fromJson( |
| value as core.Map<core.String, core.dynamic>)) |
| .toList() |
| : null, |
| writeControl: json_.containsKey('writeControl') |
| ? WriteControl.fromJson( |
| json_['writeControl'] as core.Map<core.String, core.dynamic>) |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (includeFormInResponse != null) |
| 'includeFormInResponse': includeFormInResponse!, |
| if (requests != null) 'requests': requests!, |
| if (writeControl != null) 'writeControl': writeControl!, |
| }; |
| } |
| |
| /// Response to a BatchUpdateFormRequest. |
| class BatchUpdateFormResponse { |
| /// Based on the bool request field `include_form_in_response`, a form with |
| /// all applied mutations/updates is returned or not. |
| /// |
| /// This may be later than the revision ID created by these changes. |
| Form? form; |
| |
| /// The reply of the updates. |
| /// |
| /// This maps 1:1 with the update requests, although replies to some requests |
| /// may be empty. |
| core.List<Response>? replies; |
| |
| /// The updated write control after applying the request. |
| WriteControl? writeControl; |
| |
| BatchUpdateFormResponse({ |
| this.form, |
| this.replies, |
| this.writeControl, |
| }); |
| |
| BatchUpdateFormResponse.fromJson(core.Map json_) |
| : this( |
| form: json_.containsKey('form') |
| ? Form.fromJson( |
| json_['form'] as core.Map<core.String, core.dynamic>) |
| : null, |
| replies: json_.containsKey('replies') |
| ? (json_['replies'] as core.List) |
| .map((value) => Response.fromJson( |
| value as core.Map<core.String, core.dynamic>)) |
| .toList() |
| : null, |
| writeControl: json_.containsKey('writeControl') |
| ? WriteControl.fromJson( |
| json_['writeControl'] as core.Map<core.String, core.dynamic>) |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (form != null) 'form': form!, |
| if (replies != null) 'replies': replies!, |
| if (writeControl != null) 'writeControl': writeControl!, |
| }; |
| } |
| |
| /// A radio/checkbox/dropdown question. |
| class ChoiceQuestion { |
| /// List of options that a respondent must choose from. |
| /// |
| /// Required. |
| core.List<Option>? options; |
| |
| /// Whether the options should be displayed in random order for different |
| /// instances of the quiz. |
| /// |
| /// This is often used to prevent cheating by respondents who might be looking |
| /// at another respondent's screen, or to address bias in a survey that might |
| /// be introduced by always putting the same options first or last. |
| core.bool? shuffle; |
| |
| /// The type of choice question. |
| /// |
| /// Required. |
| /// Possible string values are: |
| /// - "CHOICE_TYPE_UNSPECIFIED" : Default value. Unused. |
| /// - "RADIO" : Radio buttons: All choices are shown to the user, who can only |
| /// pick one of them. |
| /// - "CHECKBOX" : Checkboxes: All choices are shown to the user, who can pick |
| /// any number of them. |
| /// - "DROP_DOWN" : Drop-down menu: The choices are only shown to the user on |
| /// demand, otherwise only the current choice is shown. Only one option can be |
| /// chosen. |
| core.String? type; |
| |
| ChoiceQuestion({ |
| this.options, |
| this.shuffle, |
| this.type, |
| }); |
| |
| ChoiceQuestion.fromJson(core.Map json_) |
| : this( |
| options: json_.containsKey('options') |
| ? (json_['options'] as core.List) |
| .map((value) => Option.fromJson( |
| value as core.Map<core.String, core.dynamic>)) |
| .toList() |
| : null, |
| shuffle: json_.containsKey('shuffle') |
| ? json_['shuffle'] as core.bool |
| : null, |
| type: json_.containsKey('type') ? json_['type'] as core.String : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (options != null) 'options': options!, |
| if (shuffle != null) 'shuffle': shuffle!, |
| if (type != null) 'type': type!, |
| }; |
| } |
| |
| /// A Pub/Sub topic. |
| class CloudPubsubTopic { |
| /// A fully qualified Pub/Sub topic name to publish the events to. |
| /// |
| /// This topic must be owned by the calling project and already exist in |
| /// Pub/Sub. |
| /// |
| /// Required. |
| core.String? topicName; |
| |
| CloudPubsubTopic({ |
| this.topicName, |
| }); |
| |
| CloudPubsubTopic.fromJson(core.Map json_) |
| : this( |
| topicName: json_.containsKey('topicName') |
| ? json_['topicName'] as core.String |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (topicName != null) 'topicName': topicName!, |
| }; |
| } |
| |
| /// A single correct answer for a question. |
| /// |
| /// For multiple-valued (`CHECKBOX`) questions, several `CorrectAnswer`s may be |
| /// needed to represent a single correct response option. |
| class CorrectAnswer { |
| /// The correct answer value. |
| /// |
| /// See the documentation for TextAnswer.value for details on how various |
| /// value types are formatted. |
| /// |
| /// Required. |
| core.String? value; |
| |
| CorrectAnswer({ |
| this.value, |
| }); |
| |
| CorrectAnswer.fromJson(core.Map json_) |
| : this( |
| value: |
| json_.containsKey('value') ? json_['value'] as core.String : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (value != null) 'value': value!, |
| }; |
| } |
| |
| /// The answer key for a question. |
| class CorrectAnswers { |
| /// A list of correct answers. |
| /// |
| /// A quiz response can be automatically graded based on these answers. For |
| /// single-valued questions, a response is marked correct if it matches any |
| /// value in this list (in other words, multiple correct answers are |
| /// possible). For multiple-valued (`CHECKBOX`) questions, a response is |
| /// marked correct if it contains exactly the values in this list. |
| core.List<CorrectAnswer>? answers; |
| |
| CorrectAnswers({ |
| this.answers, |
| }); |
| |
| CorrectAnswers.fromJson(core.Map json_) |
| : this( |
| answers: json_.containsKey('answers') |
| ? (json_['answers'] as core.List) |
| .map((value) => CorrectAnswer.fromJson( |
| value as core.Map<core.String, core.dynamic>)) |
| .toList() |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (answers != null) 'answers': answers!, |
| }; |
| } |
| |
| /// Create an item in a form. |
| class CreateItemRequest { |
| /// The item to create. |
| /// |
| /// Required. |
| Item? item; |
| |
| /// Where to place the new item. |
| /// |
| /// Required. |
| Location? location; |
| |
| CreateItemRequest({ |
| this.item, |
| this.location, |
| }); |
| |
| CreateItemRequest.fromJson(core.Map json_) |
| : this( |
| item: json_.containsKey('item') |
| ? Item.fromJson( |
| json_['item'] as core.Map<core.String, core.dynamic>) |
| : null, |
| location: json_.containsKey('location') |
| ? Location.fromJson( |
| json_['location'] as core.Map<core.String, core.dynamic>) |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (item != null) 'item': item!, |
| if (location != null) 'location': location!, |
| }; |
| } |
| |
| /// The result of creating an item. |
| class CreateItemResponse { |
| /// The ID of the created item. |
| core.String? itemId; |
| |
| /// The ID of the question created as part of this item, for a question group |
| /// it lists IDs of all the questions created for this item. |
| core.List<core.String>? questionId; |
| |
| CreateItemResponse({ |
| this.itemId, |
| this.questionId, |
| }); |
| |
| CreateItemResponse.fromJson(core.Map json_) |
| : this( |
| itemId: json_.containsKey('itemId') |
| ? json_['itemId'] as core.String |
| : null, |
| questionId: json_.containsKey('questionId') |
| ? (json_['questionId'] as core.List) |
| .map((value) => value as core.String) |
| .toList() |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (itemId != null) 'itemId': itemId!, |
| if (questionId != null) 'questionId': questionId!, |
| }; |
| } |
| |
| /// Create a new watch. |
| class CreateWatchRequest { |
| /// The watch object. |
| /// |
| /// No ID should be set on this object; use `watch_id` instead. |
| /// |
| /// Required. |
| Watch? watch; |
| |
| /// The ID to use for the watch. |
| /// |
| /// If specified, the ID must not already be in use. If not specified, an ID |
| /// is generated. This value should be 4-63 characters, and valid characters |
| /// are /a-z-/. |
| core.String? watchId; |
| |
| CreateWatchRequest({ |
| this.watch, |
| this.watchId, |
| }); |
| |
| CreateWatchRequest.fromJson(core.Map json_) |
| : this( |
| watch: json_.containsKey('watch') |
| ? Watch.fromJson( |
| json_['watch'] as core.Map<core.String, core.dynamic>) |
| : null, |
| watchId: json_.containsKey('watchId') |
| ? json_['watchId'] as core.String |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (watch != null) 'watch': watch!, |
| if (watchId != null) 'watchId': watchId!, |
| }; |
| } |
| |
| /// A date question. |
| /// |
| /// Date questions default to just month + day. |
| class DateQuestion { |
| /// Whether to include the time as part of the question. |
| core.bool? includeTime; |
| |
| /// Whether to include the year as part of the question. |
| core.bool? includeYear; |
| |
| DateQuestion({ |
| this.includeTime, |
| this.includeYear, |
| }); |
| |
| DateQuestion.fromJson(core.Map json_) |
| : this( |
| includeTime: json_.containsKey('includeTime') |
| ? json_['includeTime'] as core.bool |
| : null, |
| includeYear: json_.containsKey('includeYear') |
| ? json_['includeYear'] as core.bool |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (includeTime != null) 'includeTime': includeTime!, |
| if (includeYear != null) 'includeYear': includeYear!, |
| }; |
| } |
| |
| /// Delete an item in a form. |
| class DeleteItemRequest { |
| /// The location of the item to delete. |
| /// |
| /// Required. |
| Location? location; |
| |
| DeleteItemRequest({ |
| this.location, |
| }); |
| |
| DeleteItemRequest.fromJson(core.Map json_) |
| : this( |
| location: json_.containsKey('location') |
| ? Location.fromJson( |
| json_['location'] as core.Map<core.String, core.dynamic>) |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (location != null) 'location': location!, |
| }; |
| } |
| |
| /// 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); } |
| typedef Empty = $Empty; |
| |
| /// Supplementary material to the feedback. |
| class ExtraMaterial { |
| /// Text feedback. |
| TextLink? link; |
| |
| /// Video feedback. |
| VideoLink? video; |
| |
| ExtraMaterial({ |
| this.link, |
| this.video, |
| }); |
| |
| ExtraMaterial.fromJson(core.Map json_) |
| : this( |
| link: json_.containsKey('link') |
| ? TextLink.fromJson( |
| json_['link'] as core.Map<core.String, core.dynamic>) |
| : null, |
| video: json_.containsKey('video') |
| ? VideoLink.fromJson( |
| json_['video'] as core.Map<core.String, core.dynamic>) |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (link != null) 'link': link!, |
| if (video != null) 'video': video!, |
| }; |
| } |
| |
| /// Feedback for a respondent about their response to a question. |
| class Feedback { |
| /// Additional information provided as part of the feedback, often used to |
| /// point the respondent to more reading and resources. |
| core.List<ExtraMaterial>? material; |
| |
| /// The main text of the feedback. |
| /// |
| /// Required. |
| core.String? text; |
| |
| Feedback({ |
| this.material, |
| this.text, |
| }); |
| |
| Feedback.fromJson(core.Map json_) |
| : this( |
| material: json_.containsKey('material') |
| ? (json_['material'] as core.List) |
| .map((value) => ExtraMaterial.fromJson( |
| value as core.Map<core.String, core.dynamic>)) |
| .toList() |
| : null, |
| text: json_.containsKey('text') ? json_['text'] as core.String : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (material != null) 'material': material!, |
| if (text != null) 'text': text!, |
| }; |
| } |
| |
| /// Info for a single file submitted to a file upload question. |
| class FileUploadAnswer { |
| /// The ID of the Google Drive file. |
| /// |
| /// Output only. |
| core.String? fileId; |
| |
| /// The file name, as stored in Google Drive on upload. |
| /// |
| /// Output only. |
| core.String? fileName; |
| |
| /// The MIME type of the file, as stored in Google Drive on upload. |
| /// |
| /// Output only. |
| core.String? mimeType; |
| |
| FileUploadAnswer({ |
| this.fileId, |
| this.fileName, |
| this.mimeType, |
| }); |
| |
| FileUploadAnswer.fromJson(core.Map json_) |
| : this( |
| fileId: json_.containsKey('fileId') |
| ? json_['fileId'] as core.String |
| : null, |
| fileName: json_.containsKey('fileName') |
| ? json_['fileName'] as core.String |
| : null, |
| mimeType: json_.containsKey('mimeType') |
| ? json_['mimeType'] as core.String |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (fileId != null) 'fileId': fileId!, |
| if (fileName != null) 'fileName': fileName!, |
| if (mimeType != null) 'mimeType': mimeType!, |
| }; |
| } |
| |
| /// All submitted files for a FileUpload question. |
| class FileUploadAnswers { |
| /// All submitted files for a FileUpload question. |
| /// |
| /// Output only. |
| core.List<FileUploadAnswer>? answers; |
| |
| FileUploadAnswers({ |
| this.answers, |
| }); |
| |
| FileUploadAnswers.fromJson(core.Map json_) |
| : this( |
| answers: json_.containsKey('answers') |
| ? (json_['answers'] as core.List) |
| .map((value) => FileUploadAnswer.fromJson( |
| value as core.Map<core.String, core.dynamic>)) |
| .toList() |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (answers != null) 'answers': answers!, |
| }; |
| } |
| |
| /// A file upload question. |
| /// |
| /// The API currently does not support creating file upload questions. |
| class FileUploadQuestion { |
| /// The ID of the Drive folder where uploaded files are stored. |
| /// |
| /// Required. |
| core.String? folderId; |
| |
| /// Maximum number of bytes allowed for any single file uploaded to this |
| /// question. |
| core.String? maxFileSize; |
| |
| /// Maximum number of files that can be uploaded for this question in a single |
| /// response. |
| core.int? maxFiles; |
| |
| /// File types accepted by this question. |
| core.List<core.String>? types; |
| |
| FileUploadQuestion({ |
| this.folderId, |
| this.maxFileSize, |
| this.maxFiles, |
| this.types, |
| }); |
| |
| FileUploadQuestion.fromJson(core.Map json_) |
| : this( |
| folderId: json_.containsKey('folderId') |
| ? json_['folderId'] as core.String |
| : null, |
| maxFileSize: json_.containsKey('maxFileSize') |
| ? json_['maxFileSize'] as core.String |
| : null, |
| maxFiles: json_.containsKey('maxFiles') |
| ? json_['maxFiles'] as core.int |
| : null, |
| types: json_.containsKey('types') |
| ? (json_['types'] as core.List) |
| .map((value) => value as core.String) |
| .toList() |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (folderId != null) 'folderId': folderId!, |
| if (maxFileSize != null) 'maxFileSize': maxFileSize!, |
| if (maxFiles != null) 'maxFiles': maxFiles!, |
| if (types != null) 'types': types!, |
| }; |
| } |
| |
| /// A Google Forms document. |
| /// |
| /// A form is created in Drive, and deleting a form or changing its access |
| /// protections is done via the |
| /// [Drive API](https://developers.google.com/drive/api/v3/about-sdk). |
| class Form { |
| /// The form ID. |
| /// |
| /// Output only. |
| core.String? formId; |
| |
| /// The title and description of the form. |
| /// |
| /// Required. |
| Info? info; |
| |
| /// A list of the form's items, which can include section headers, questions, |
| /// embedded media, etc. |
| /// |
| /// Required. |
| core.List<Item>? items; |
| |
| /// The ID of the linked Google Sheet which is accumulating responses from |
| /// this Form (if such a Sheet exists). |
| /// |
| /// Output only. |
| core.String? linkedSheetId; |
| |
| /// The form URI to share with responders. |
| /// |
| /// This opens a page that allows the user to submit responses but not edit |
| /// the questions. |
| /// |
| /// Output only. |
| core.String? responderUri; |
| |
| /// The revision ID of the form. |
| /// |
| /// Used in the WriteControl in update requests to identify the revision on |
| /// which the changes are based. The format of the revision ID may change over |
| /// time, so it should be treated opaquely. A returned revision ID is only |
| /// guaranteed to be valid for 24 hours after it has been returned and cannot |
| /// be shared across users. If the revision ID is unchanged between calls, |
| /// then the form has not changed. Conversely, a changed ID (for the same form |
| /// and user) usually means the form has been updated; however, a changed ID |
| /// can also be due to internal factors such as ID format changes. |
| /// |
| /// Output only. |
| core.String? revisionId; |
| |
| /// The form's settings. |
| /// |
| /// This must be updated with UpdateSettingsRequest; it is ignored during |
| /// `forms.create` and UpdateFormInfoRequest. |
| FormSettings? settings; |
| |
| Form({ |
| this.formId, |
| this.info, |
| this.items, |
| this.linkedSheetId, |
| this.responderUri, |
| this.revisionId, |
| this.settings, |
| }); |
| |
| Form.fromJson(core.Map json_) |
| : this( |
| formId: json_.containsKey('formId') |
| ? json_['formId'] as core.String |
| : null, |
| info: json_.containsKey('info') |
| ? Info.fromJson( |
| json_['info'] as core.Map<core.String, core.dynamic>) |
| : null, |
| items: json_.containsKey('items') |
| ? (json_['items'] as core.List) |
| .map((value) => Item.fromJson( |
| value as core.Map<core.String, core.dynamic>)) |
| .toList() |
| : null, |
| linkedSheetId: json_.containsKey('linkedSheetId') |
| ? json_['linkedSheetId'] as core.String |
| : null, |
| responderUri: json_.containsKey('responderUri') |
| ? json_['responderUri'] as core.String |
| : null, |
| revisionId: json_.containsKey('revisionId') |
| ? json_['revisionId'] as core.String |
| : null, |
| settings: json_.containsKey('settings') |
| ? FormSettings.fromJson( |
| json_['settings'] as core.Map<core.String, core.dynamic>) |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (formId != null) 'formId': formId!, |
| if (info != null) 'info': info!, |
| if (items != null) 'items': items!, |
| if (linkedSheetId != null) 'linkedSheetId': linkedSheetId!, |
| if (responderUri != null) 'responderUri': responderUri!, |
| if (revisionId != null) 'revisionId': revisionId!, |
| if (settings != null) 'settings': settings!, |
| }; |
| } |
| |
| /// A form response. |
| class FormResponse { |
| /// The actual answers to the questions, keyed by question_id. |
| /// |
| /// Output only. |
| core.Map<core.String, Answer>? answers; |
| |
| /// Timestamp for the first time the response was submitted. |
| /// |
| /// Output only. |
| core.String? createTime; |
| |
| /// The form ID. |
| /// |
| /// Output only. |
| core.String? formId; |
| |
| /// Timestamp for the most recent time the response was submitted. |
| /// |
| /// Does not track changes to grades. |
| /// |
| /// Output only. |
| core.String? lastSubmittedTime; |
| |
| /// The email address (if collected) for the respondent. |
| /// |
| /// Output only. |
| core.String? respondentEmail; |
| |
| /// The response ID. |
| /// |
| /// Output only. |
| core.String? responseId; |
| |
| /// The total number of points the respondent received for their submission |
| /// Only set if the form was a quiz and the response was graded. |
| /// |
| /// This includes points automatically awarded via autograding adjusted by any |
| /// manual corrections entered by the form owner. |
| /// |
| /// Output only. |
| core.double? totalScore; |
| |
| FormResponse({ |
| this.answers, |
| this.createTime, |
| this.formId, |
| this.lastSubmittedTime, |
| this.respondentEmail, |
| this.responseId, |
| this.totalScore, |
| }); |
| |
| FormResponse.fromJson(core.Map json_) |
| : this( |
| answers: json_.containsKey('answers') |
| ? (json_['answers'] as core.Map<core.String, core.dynamic>).map( |
| (key, item) => core.MapEntry( |
| key, |
| Answer.fromJson( |
| item as core.Map<core.String, core.dynamic>), |
| ), |
| ) |
| : null, |
| createTime: json_.containsKey('createTime') |
| ? json_['createTime'] as core.String |
| : null, |
| formId: json_.containsKey('formId') |
| ? json_['formId'] as core.String |
| : null, |
| lastSubmittedTime: json_.containsKey('lastSubmittedTime') |
| ? json_['lastSubmittedTime'] as core.String |
| : null, |
| respondentEmail: json_.containsKey('respondentEmail') |
| ? json_['respondentEmail'] as core.String |
| : null, |
| responseId: json_.containsKey('responseId') |
| ? json_['responseId'] as core.String |
| : null, |
| totalScore: json_.containsKey('totalScore') |
| ? (json_['totalScore'] as core.num).toDouble() |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (answers != null) 'answers': answers!, |
| if (createTime != null) 'createTime': createTime!, |
| if (formId != null) 'formId': formId!, |
| if (lastSubmittedTime != null) 'lastSubmittedTime': lastSubmittedTime!, |
| if (respondentEmail != null) 'respondentEmail': respondentEmail!, |
| if (responseId != null) 'responseId': responseId!, |
| if (totalScore != null) 'totalScore': totalScore!, |
| }; |
| } |
| |
| /// A form's settings. |
| class FormSettings { |
| /// Settings related to quiz forms and grading. |
| QuizSettings? quizSettings; |
| |
| FormSettings({ |
| this.quizSettings, |
| }); |
| |
| FormSettings.fromJson(core.Map json_) |
| : this( |
| quizSettings: json_.containsKey('quizSettings') |
| ? QuizSettings.fromJson( |
| json_['quizSettings'] as core.Map<core.String, core.dynamic>) |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (quizSettings != null) 'quizSettings': quizSettings!, |
| }; |
| } |
| |
| /// Grade information associated with a respondent's answer to a question. |
| class Grade { |
| /// Whether the question was answered correctly or not. |
| /// |
| /// A zero-point score is not enough to infer incorrectness, since a correctly |
| /// answered question could be worth zero points. |
| /// |
| /// Output only. |
| core.bool? correct; |
| |
| /// Additional feedback given for an answer. |
| /// |
| /// Output only. |
| Feedback? feedback; |
| |
| /// The numeric score awarded for the answer. |
| /// |
| /// Output only. |
| core.double? score; |
| |
| Grade({ |
| this.correct, |
| this.feedback, |
| this.score, |
| }); |
| |
| Grade.fromJson(core.Map json_) |
| : this( |
| correct: json_.containsKey('correct') |
| ? json_['correct'] as core.bool |
| : null, |
| feedback: json_.containsKey('feedback') |
| ? Feedback.fromJson( |
| json_['feedback'] as core.Map<core.String, core.dynamic>) |
| : null, |
| score: json_.containsKey('score') |
| ? (json_['score'] as core.num).toDouble() |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (correct != null) 'correct': correct!, |
| if (feedback != null) 'feedback': feedback!, |
| if (score != null) 'score': score!, |
| }; |
| } |
| |
| /// Grading for a single question |
| class Grading { |
| /// The answer key for the question. |
| /// |
| /// Responses are automatically graded based on this field. |
| /// |
| /// Required. |
| CorrectAnswers? correctAnswers; |
| |
| /// The feedback displayed for all answers. |
| /// |
| /// This is commonly used for short answer questions when a quiz owner wants |
| /// to quickly give respondents some sense of whether they answered the |
| /// question correctly before they've had a chance to officially grade the |
| /// response. General feedback cannot be set for automatically graded multiple |
| /// choice questions. |
| Feedback? generalFeedback; |
| |
| /// The maximum number of points a respondent can automatically get for a |
| /// correct answer. |
| /// |
| /// This must not be negative. |
| /// |
| /// Required. |
| core.int? pointValue; |
| |
| /// The feedback displayed for correct responses. |
| /// |
| /// This feedback can only be set for multiple choice questions that have |
| /// correct answers provided. |
| Feedback? whenRight; |
| |
| /// The feedback displayed for incorrect responses. |
| /// |
| /// This feedback can only be set for multiple choice questions that have |
| /// correct answers provided. |
| Feedback? whenWrong; |
| |
| Grading({ |
| this.correctAnswers, |
| this.generalFeedback, |
| this.pointValue, |
| this.whenRight, |
| this.whenWrong, |
| }); |
| |
| Grading.fromJson(core.Map json_) |
| : this( |
| correctAnswers: json_.containsKey('correctAnswers') |
| ? CorrectAnswers.fromJson(json_['correctAnswers'] |
| as core.Map<core.String, core.dynamic>) |
| : null, |
| generalFeedback: json_.containsKey('generalFeedback') |
| ? Feedback.fromJson(json_['generalFeedback'] |
| as core.Map<core.String, core.dynamic>) |
| : null, |
| pointValue: json_.containsKey('pointValue') |
| ? json_['pointValue'] as core.int |
| : null, |
| whenRight: json_.containsKey('whenRight') |
| ? Feedback.fromJson( |
| json_['whenRight'] as core.Map<core.String, core.dynamic>) |
| : null, |
| whenWrong: json_.containsKey('whenWrong') |
| ? Feedback.fromJson( |
| json_['whenWrong'] as core.Map<core.String, core.dynamic>) |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (correctAnswers != null) 'correctAnswers': correctAnswers!, |
| if (generalFeedback != null) 'generalFeedback': generalFeedback!, |
| if (pointValue != null) 'pointValue': pointValue!, |
| if (whenRight != null) 'whenRight': whenRight!, |
| if (whenWrong != null) 'whenWrong': whenWrong!, |
| }; |
| } |
| |
| /// A grid of choices (radio or check boxes) with each row constituting a |
| /// separate question. |
| /// |
| /// Each row has the same choices, which are shown as the columns. |
| class Grid { |
| /// The choices shared by each question in the grid. |
| /// |
| /// In other words, the values of the columns. Only `CHECK_BOX` and `RADIO` |
| /// choices are allowed. |
| /// |
| /// Required. |
| ChoiceQuestion? columns; |
| |
| /// If `true`, the questions are randomly ordered. |
| /// |
| /// In other words, the rows appear in a different order for every respondent. |
| core.bool? shuffleQuestions; |
| |
| Grid({ |
| this.columns, |
| this.shuffleQuestions, |
| }); |
| |
| Grid.fromJson(core.Map json_) |
| : this( |
| columns: json_.containsKey('columns') |
| ? ChoiceQuestion.fromJson( |
| json_['columns'] as core.Map<core.String, core.dynamic>) |
| : null, |
| shuffleQuestions: json_.containsKey('shuffleQuestions') |
| ? json_['shuffleQuestions'] as core.bool |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (columns != null) 'columns': columns!, |
| if (shuffleQuestions != null) 'shuffleQuestions': shuffleQuestions!, |
| }; |
| } |
| |
| /// Data representing an image. |
| class Image { |
| /// A description of the image that is shown on hover and read by |
| /// screenreaders. |
| core.String? altText; |
| |
| /// A URI from which you can download the image; this is valid only for a |
| /// limited time. |
| /// |
| /// Output only. |
| core.String? contentUri; |
| |
| /// Properties of an image. |
| MediaProperties? properties; |
| |
| /// Input only. |
| /// |
| /// The source URI is the URI used to insert the image. The source URI can be |
| /// empty when fetched. |
| core.String? sourceUri; |
| |
| Image({ |
| this.altText, |
| this.contentUri, |
| this.properties, |
| this.sourceUri, |
| }); |
| |
| Image.fromJson(core.Map json_) |
| : this( |
| altText: json_.containsKey('altText') |
| ? json_['altText'] as core.String |
| : null, |
| contentUri: json_.containsKey('contentUri') |
| ? json_['contentUri'] as core.String |
| : null, |
| properties: json_.containsKey('properties') |
| ? MediaProperties.fromJson( |
| json_['properties'] as core.Map<core.String, core.dynamic>) |
| : null, |
| sourceUri: json_.containsKey('sourceUri') |
| ? json_['sourceUri'] as core.String |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (altText != null) 'altText': altText!, |
| if (contentUri != null) 'contentUri': contentUri!, |
| if (properties != null) 'properties': properties!, |
| if (sourceUri != null) 'sourceUri': sourceUri!, |
| }; |
| } |
| |
| /// An item containing an image. |
| class ImageItem { |
| /// The image displayed in the item. |
| /// |
| /// Required. |
| Image? image; |
| |
| ImageItem({ |
| this.image, |
| }); |
| |
| ImageItem.fromJson(core.Map json_) |
| : this( |
| image: json_.containsKey('image') |
| ? Image.fromJson( |
| json_['image'] as core.Map<core.String, core.dynamic>) |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (image != null) 'image': image!, |
| }; |
| } |
| |
| /// The general information for a form. |
| class Info { |
| /// The description of the form. |
| core.String? description; |
| |
| /// The title of the document which is visible in Drive. |
| /// |
| /// If `Info.title` is empty, `document_title` may appear in its place in the |
| /// Google Forms UI and be visible to responders. `document_title` can be set |
| /// on create, but cannot be modified by a batchUpdate request. Please use the |
| /// [Google Drive API](https://developers.google.com/drive/api/v3/reference/files/update) |
| /// if you need to programmatically update `document_title`. |
| /// |
| /// Output only. |
| core.String? documentTitle; |
| |
| /// The title of the form which is visible to responders. |
| /// |
| /// Required. |
| core.String? title; |
| |
| Info({ |
| this.description, |
| this.documentTitle, |
| this.title, |
| }); |
| |
| Info.fromJson(core.Map json_) |
| : this( |
| description: json_.containsKey('description') |
| ? json_['description'] as core.String |
| : null, |
| documentTitle: json_.containsKey('documentTitle') |
| ? json_['documentTitle'] as core.String |
| : null, |
| title: |
| json_.containsKey('title') ? json_['title'] as core.String : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (description != null) 'description': description!, |
| if (documentTitle != null) 'documentTitle': documentTitle!, |
| if (title != null) 'title': title!, |
| }; |
| } |
| |
| /// A single item of the form. |
| /// |
| /// `kind` defines which kind of item it is. |
| class Item { |
| /// The description of the item. |
| core.String? description; |
| |
| /// Displays an image on the page. |
| ImageItem? imageItem; |
| |
| /// The item ID. |
| /// |
| /// On creation, it can be provided but the ID must not be already used in the |
| /// form. If not provided, a new ID is assigned. |
| core.String? itemId; |
| |
| /// Starts a new page with a title. |
| PageBreakItem? pageBreakItem; |
| |
| /// Poses one or more questions to the user with a single major prompt. |
| QuestionGroupItem? questionGroupItem; |
| |
| /// Poses a question to the user. |
| QuestionItem? questionItem; |
| |
| /// Displays a title and description on the page. |
| TextItem? textItem; |
| |
| /// The title of the item. |
| core.String? title; |
| |
| /// Displays a video on the page. |
| VideoItem? videoItem; |
| |
| Item({ |
| this.description, |
| this.imageItem, |
| this.itemId, |
| this.pageBreakItem, |
| this.questionGroupItem, |
| this.questionItem, |
| this.textItem, |
| this.title, |
| this.videoItem, |
| }); |
| |
| Item.fromJson(core.Map json_) |
| : this( |
| description: json_.containsKey('description') |
| ? json_['description'] as core.String |
| : null, |
| imageItem: json_.containsKey('imageItem') |
| ? ImageItem.fromJson( |
| json_['imageItem'] as core.Map<core.String, core.dynamic>) |
| : null, |
| itemId: json_.containsKey('itemId') |
| ? json_['itemId'] as core.String |
| : null, |
| pageBreakItem: json_.containsKey('pageBreakItem') |
| ? PageBreakItem.fromJson( |
| json_['pageBreakItem'] as core.Map<core.String, core.dynamic>) |
| : null, |
| questionGroupItem: json_.containsKey('questionGroupItem') |
| ? QuestionGroupItem.fromJson(json_['questionGroupItem'] |
| as core.Map<core.String, core.dynamic>) |
| : null, |
| questionItem: json_.containsKey('questionItem') |
| ? QuestionItem.fromJson( |
| json_['questionItem'] as core.Map<core.String, core.dynamic>) |
| : null, |
| textItem: json_.containsKey('textItem') |
| ? TextItem.fromJson( |
| json_['textItem'] as core.Map<core.String, core.dynamic>) |
| : null, |
| title: |
| json_.containsKey('title') ? json_['title'] as core.String : null, |
| videoItem: json_.containsKey('videoItem') |
| ? VideoItem.fromJson( |
| json_['videoItem'] as core.Map<core.String, core.dynamic>) |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (description != null) 'description': description!, |
| if (imageItem != null) 'imageItem': imageItem!, |
| if (itemId != null) 'itemId': itemId!, |
| if (pageBreakItem != null) 'pageBreakItem': pageBreakItem!, |
| if (questionGroupItem != null) 'questionGroupItem': questionGroupItem!, |
| if (questionItem != null) 'questionItem': questionItem!, |
| if (textItem != null) 'textItem': textItem!, |
| if (title != null) 'title': title!, |
| if (videoItem != null) 'videoItem': videoItem!, |
| }; |
| } |
| |
| /// Response to a ListFormResponsesRequest. |
| class ListFormResponsesResponse { |
| /// If set, there are more responses. |
| /// |
| /// To get the next page of responses, provide this as `page_token` in a |
| /// future request. |
| core.String? nextPageToken; |
| |
| /// The returned form responses. |
| /// |
| /// Note: The `formId` field is not returned in the `FormResponse` object for |
| /// list requests. |
| core.List<FormResponse>? responses; |
| |
| ListFormResponsesResponse({ |
| this.nextPageToken, |
| this.responses, |
| }); |
| |
| ListFormResponsesResponse.fromJson(core.Map json_) |
| : this( |
| nextPageToken: json_.containsKey('nextPageToken') |
| ? json_['nextPageToken'] as core.String |
| : null, |
| responses: json_.containsKey('responses') |
| ? (json_['responses'] as core.List) |
| .map((value) => FormResponse.fromJson( |
| value as core.Map<core.String, core.dynamic>)) |
| .toList() |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (nextPageToken != null) 'nextPageToken': nextPageToken!, |
| if (responses != null) 'responses': responses!, |
| }; |
| } |
| |
| /// The response of a ListWatchesRequest. |
| class ListWatchesResponse { |
| /// The returned watches. |
| core.List<Watch>? watches; |
| |
| ListWatchesResponse({ |
| this.watches, |
| }); |
| |
| ListWatchesResponse.fromJson(core.Map json_) |
| : this( |
| watches: json_.containsKey('watches') |
| ? (json_['watches'] as core.List) |
| .map((value) => Watch.fromJson( |
| value as core.Map<core.String, core.dynamic>)) |
| .toList() |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (watches != null) 'watches': watches!, |
| }; |
| } |
| |
| /// A specific location in a form. |
| class Location { |
| /// The index of an item in the form. |
| /// |
| /// This must be in the range \[0..*N*), where *N* is the number of items in |
| /// the form. |
| core.int? index; |
| |
| Location({ |
| this.index, |
| }); |
| |
| Location.fromJson(core.Map json_) |
| : this( |
| index: json_.containsKey('index') ? json_['index'] as core.int : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (index != null) 'index': index!, |
| }; |
| } |
| |
| /// Properties of the media. |
| class MediaProperties { |
| /// Position of the media. |
| /// Possible string values are: |
| /// - "ALIGNMENT_UNSPECIFIED" : Default value. Unused. |
| /// - "LEFT" : Left align. |
| /// - "RIGHT" : Right align. |
| /// - "CENTER" : Center. |
| core.String? alignment; |
| |
| /// The width of the media in pixels. |
| /// |
| /// When the media is displayed, it is scaled to the smaller of this value or |
| /// the width of the displayed form. The original aspect ratio of the media is |
| /// preserved. If a width is not specified when the media is added to the |
| /// form, it is set to the width of the media source. Width must be between 0 |
| /// and 740, inclusive. Setting width to 0 or unspecified is only permitted |
| /// when updating the media source. |
| core.int? width; |
| |
| MediaProperties({ |
| this.alignment, |
| this.width, |
| }); |
| |
| MediaProperties.fromJson(core.Map json_) |
| : this( |
| alignment: json_.containsKey('alignment') |
| ? json_['alignment'] as core.String |
| : null, |
| width: json_.containsKey('width') ? json_['width'] as core.int : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (alignment != null) 'alignment': alignment!, |
| if (width != null) 'width': width!, |
| }; |
| } |
| |
| /// Move an item in a form. |
| class MoveItemRequest { |
| /// The new location for the item. |
| /// |
| /// Required. |
| Location? newLocation; |
| |
| /// The location of the item to move. |
| /// |
| /// Required. |
| Location? originalLocation; |
| |
| MoveItemRequest({ |
| this.newLocation, |
| this.originalLocation, |
| }); |
| |
| MoveItemRequest.fromJson(core.Map json_) |
| : this( |
| newLocation: json_.containsKey('newLocation') |
| ? Location.fromJson( |
| json_['newLocation'] as core.Map<core.String, core.dynamic>) |
| : null, |
| originalLocation: json_.containsKey('originalLocation') |
| ? Location.fromJson(json_['originalLocation'] |
| as core.Map<core.String, core.dynamic>) |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (newLocation != null) 'newLocation': newLocation!, |
| if (originalLocation != null) 'originalLocation': originalLocation!, |
| }; |
| } |
| |
| /// An option for a Choice question. |
| class Option { |
| /// Section navigation type. |
| /// Possible string values are: |
| /// - "GO_TO_ACTION_UNSPECIFIED" : Default value. Unused. |
| /// - "NEXT_SECTION" : Go to the next section. |
| /// - "RESTART_FORM" : Go back to the beginning of the form. |
| /// - "SUBMIT_FORM" : Submit form immediately. |
| core.String? goToAction; |
| |
| /// Item ID of section header to go to. |
| core.String? goToSectionId; |
| |
| /// Display image as an option. |
| Image? image; |
| |
| /// Whether the option is "other". |
| /// |
| /// Currently only applies to `RADIO` and `CHECKBOX` choice types, but is not |
| /// allowed in a QuestionGroupItem. |
| core.bool? isOther; |
| |
| /// The choice as presented to the user. |
| /// |
| /// Required. |
| core.String? value; |
| |
| Option({ |
| this.goToAction, |
| this.goToSectionId, |
| this.image, |
| this.isOther, |
| this.value, |
| }); |
| |
| Option.fromJson(core.Map json_) |
| : this( |
| goToAction: json_.containsKey('goToAction') |
| ? json_['goToAction'] as core.String |
| : null, |
| goToSectionId: json_.containsKey('goToSectionId') |
| ? json_['goToSectionId'] as core.String |
| : null, |
| image: json_.containsKey('image') |
| ? Image.fromJson( |
| json_['image'] as core.Map<core.String, core.dynamic>) |
| : null, |
| isOther: json_.containsKey('isOther') |
| ? json_['isOther'] as core.bool |
| : null, |
| value: |
| json_.containsKey('value') ? json_['value'] as core.String : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (goToAction != null) 'goToAction': goToAction!, |
| if (goToSectionId != null) 'goToSectionId': goToSectionId!, |
| if (image != null) 'image': image!, |
| if (isOther != null) 'isOther': isOther!, |
| if (value != null) 'value': value!, |
| }; |
| } |
| |
| /// A page break. |
| /// |
| /// The title and description of this item are shown at the top of the new page. |
| typedef PageBreakItem = $Empty; |
| |
| /// Any question. |
| /// |
| /// The specific type of question is known by its `kind`. |
| class Question { |
| /// A respondent can choose from a pre-defined set of options. |
| ChoiceQuestion? choiceQuestion; |
| |
| /// A respondent can enter a date. |
| DateQuestion? dateQuestion; |
| |
| /// A respondent can upload one or more files. |
| FileUploadQuestion? fileUploadQuestion; |
| |
| /// Grading setup for the question. |
| Grading? grading; |
| |
| /// Read only. |
| /// |
| /// The question ID. On creation, it can be provided but the ID must not be |
| /// already used in the form. If not provided, a new ID is assigned. |
| core.String? questionId; |
| |
| /// Whether the question must be answered in order for a respondent to submit |
| /// their response. |
| core.bool? required; |
| |
| /// A row of a QuestionGroupItem. |
| RowQuestion? rowQuestion; |
| |
| /// A respondent can choose a number from a range. |
| ScaleQuestion? scaleQuestion; |
| |
| /// A respondent can enter a free text response. |
| TextQuestion? textQuestion; |
| |
| /// A respondent can enter a time. |
| TimeQuestion? timeQuestion; |
| |
| Question({ |
| this.choiceQuestion, |
| this.dateQuestion, |
| this.fileUploadQuestion, |
| this.grading, |
| this.questionId, |
| this.required, |
| this.rowQuestion, |
| this.scaleQuestion, |
| this.textQuestion, |
| this.timeQuestion, |
| }); |
| |
| Question.fromJson(core.Map json_) |
| : this( |
| choiceQuestion: json_.containsKey('choiceQuestion') |
| ? ChoiceQuestion.fromJson(json_['choiceQuestion'] |
| as core.Map<core.String, core.dynamic>) |
| : null, |
| dateQuestion: json_.containsKey('dateQuestion') |
| ? DateQuestion.fromJson( |
| json_['dateQuestion'] as core.Map<core.String, core.dynamic>) |
| : null, |
| fileUploadQuestion: json_.containsKey('fileUploadQuestion') |
| ? FileUploadQuestion.fromJson(json_['fileUploadQuestion'] |
| as core.Map<core.String, core.dynamic>) |
| : null, |
| grading: json_.containsKey('grading') |
| ? Grading.fromJson( |
| json_['grading'] as core.Map<core.String, core.dynamic>) |
| : null, |
| questionId: json_.containsKey('questionId') |
| ? json_['questionId'] as core.String |
| : null, |
| required: json_.containsKey('required') |
| ? json_['required'] as core.bool |
| : null, |
| rowQuestion: json_.containsKey('rowQuestion') |
| ? RowQuestion.fromJson( |
| json_['rowQuestion'] as core.Map<core.String, core.dynamic>) |
| : null, |
| scaleQuestion: json_.containsKey('scaleQuestion') |
| ? ScaleQuestion.fromJson( |
| json_['scaleQuestion'] as core.Map<core.String, core.dynamic>) |
| : null, |
| textQuestion: json_.containsKey('textQuestion') |
| ? TextQuestion.fromJson( |
| json_['textQuestion'] as core.Map<core.String, core.dynamic>) |
| : null, |
| timeQuestion: json_.containsKey('timeQuestion') |
| ? TimeQuestion.fromJson( |
| json_['timeQuestion'] as core.Map<core.String, core.dynamic>) |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (choiceQuestion != null) 'choiceQuestion': choiceQuestion!, |
| if (dateQuestion != null) 'dateQuestion': dateQuestion!, |
| if (fileUploadQuestion != null) |
| 'fileUploadQuestion': fileUploadQuestion!, |
| if (grading != null) 'grading': grading!, |
| if (questionId != null) 'questionId': questionId!, |
| if (required != null) 'required': required!, |
| if (rowQuestion != null) 'rowQuestion': rowQuestion!, |
| if (scaleQuestion != null) 'scaleQuestion': scaleQuestion!, |
| if (textQuestion != null) 'textQuestion': textQuestion!, |
| if (timeQuestion != null) 'timeQuestion': timeQuestion!, |
| }; |
| } |
| |
| /// Defines a question that comprises multiple questions grouped together. |
| class QuestionGroupItem { |
| /// The question group is a grid with rows of multiple choice questions that |
| /// share the same options. |
| /// |
| /// When `grid` is set, all questions in the group must be of kind `row`. |
| Grid? grid; |
| |
| /// The image displayed within the question group above the specific |
| /// questions. |
| Image? image; |
| |
| /// A list of questions that belong in this question group. |
| /// |
| /// A question must only belong to one group. The `kind` of the group may |
| /// affect what types of questions are allowed. |
| /// |
| /// Required. |
| core.List<Question>? questions; |
| |
| QuestionGroupItem({ |
| this.grid, |
| this.image, |
| this.questions, |
| }); |
| |
| QuestionGroupItem.fromJson(core.Map json_) |
| : this( |
| grid: json_.containsKey('grid') |
| ? Grid.fromJson( |
| json_['grid'] as core.Map<core.String, core.dynamic>) |
| : null, |
| image: json_.containsKey('image') |
| ? Image.fromJson( |
| json_['image'] as core.Map<core.String, core.dynamic>) |
| : null, |
| questions: json_.containsKey('questions') |
| ? (json_['questions'] as core.List) |
| .map((value) => Question.fromJson( |
| value as core.Map<core.String, core.dynamic>)) |
| .toList() |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (grid != null) 'grid': grid!, |
| if (image != null) 'image': image!, |
| if (questions != null) 'questions': questions!, |
| }; |
| } |
| |
| /// A form item containing a single question. |
| class QuestionItem { |
| /// The image displayed within the question. |
| Image? image; |
| |
| /// The displayed question. |
| /// |
| /// Required. |
| Question? question; |
| |
| QuestionItem({ |
| this.image, |
| this.question, |
| }); |
| |
| QuestionItem.fromJson(core.Map json_) |
| : this( |
| image: json_.containsKey('image') |
| ? Image.fromJson( |
| json_['image'] as core.Map<core.String, core.dynamic>) |
| : null, |
| question: json_.containsKey('question') |
| ? Question.fromJson( |
| json_['question'] as core.Map<core.String, core.dynamic>) |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (image != null) 'image': image!, |
| if (question != null) 'question': question!, |
| }; |
| } |
| |
| /// Settings related to quiz forms and grading. |
| /// |
| /// These must be updated with the UpdateSettingsRequest. |
| class QuizSettings { |
| /// Whether this form is a quiz or not. |
| /// |
| /// When true, responses are graded based on question Grading. Upon setting to |
| /// false, all question Grading is deleted. |
| core.bool? isQuiz; |
| |
| QuizSettings({ |
| this.isQuiz, |
| }); |
| |
| QuizSettings.fromJson(core.Map json_) |
| : this( |
| isQuiz: |
| json_.containsKey('isQuiz') ? json_['isQuiz'] as core.bool : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (isQuiz != null) 'isQuiz': isQuiz!, |
| }; |
| } |
| |
| /// Renew an existing Watch for seven days. |
| typedef RenewWatchRequest = $Empty; |
| |
| /// The kinds of update requests that can be made. |
| class Request { |
| /// Create a new item. |
| CreateItemRequest? createItem; |
| |
| /// Delete an item. |
| DeleteItemRequest? deleteItem; |
| |
| /// Move an item to a specified location. |
| MoveItemRequest? moveItem; |
| |
| /// Update Form's Info. |
| UpdateFormInfoRequest? updateFormInfo; |
| |
| /// Update an item. |
| UpdateItemRequest? updateItem; |
| |
| /// Updates the Form's settings. |
| UpdateSettingsRequest? updateSettings; |
| |
| Request({ |
| this.createItem, |
| this.deleteItem, |
| this.moveItem, |
| this.updateFormInfo, |
| this.updateItem, |
| this.updateSettings, |
| }); |
| |
| Request.fromJson(core.Map json_) |
| : this( |
| createItem: json_.containsKey('createItem') |
| ? CreateItemRequest.fromJson( |
| json_['createItem'] as core.Map<core.String, core.dynamic>) |
| : null, |
| deleteItem: json_.containsKey('deleteItem') |
| ? DeleteItemRequest.fromJson( |
| json_['deleteItem'] as core.Map<core.String, core.dynamic>) |
| : null, |
| moveItem: json_.containsKey('moveItem') |
| ? MoveItemRequest.fromJson( |
| json_['moveItem'] as core.Map<core.String, core.dynamic>) |
| : null, |
| updateFormInfo: json_.containsKey('updateFormInfo') |
| ? UpdateFormInfoRequest.fromJson(json_['updateFormInfo'] |
| as core.Map<core.String, core.dynamic>) |
| : null, |
| updateItem: json_.containsKey('updateItem') |
| ? UpdateItemRequest.fromJson( |
| json_['updateItem'] as core.Map<core.String, core.dynamic>) |
| : null, |
| updateSettings: json_.containsKey('updateSettings') |
| ? UpdateSettingsRequest.fromJson(json_['updateSettings'] |
| as core.Map<core.String, core.dynamic>) |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (createItem != null) 'createItem': createItem!, |
| if (deleteItem != null) 'deleteItem': deleteItem!, |
| if (moveItem != null) 'moveItem': moveItem!, |
| if (updateFormInfo != null) 'updateFormInfo': updateFormInfo!, |
| if (updateItem != null) 'updateItem': updateItem!, |
| if (updateSettings != null) 'updateSettings': updateSettings!, |
| }; |
| } |
| |
| /// A single response from an update. |
| class Response { |
| /// The result of creating an item. |
| CreateItemResponse? createItem; |
| |
| Response({ |
| this.createItem, |
| }); |
| |
| Response.fromJson(core.Map json_) |
| : this( |
| createItem: json_.containsKey('createItem') |
| ? CreateItemResponse.fromJson( |
| json_['createItem'] as core.Map<core.String, core.dynamic>) |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (createItem != null) 'createItem': createItem!, |
| }; |
| } |
| |
| /// Configuration for a question that is part of a question group. |
| class RowQuestion { |
| /// The title for the single row in the QuestionGroupItem. |
| /// |
| /// Required. |
| core.String? title; |
| |
| RowQuestion({ |
| this.title, |
| }); |
| |
| RowQuestion.fromJson(core.Map json_) |
| : this( |
| title: |
| json_.containsKey('title') ? json_['title'] as core.String : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (title != null) 'title': title!, |
| }; |
| } |
| |
| /// A scale question. |
| /// |
| /// The user has a range of numeric values to choose from. |
| class ScaleQuestion { |
| /// The highest possible value for the scale. |
| /// |
| /// Required. |
| core.int? high; |
| |
| /// The label to display describing the highest point on the scale. |
| core.String? highLabel; |
| |
| /// The lowest possible value for the scale. |
| /// |
| /// Required. |
| core.int? low; |
| |
| /// The label to display describing the lowest point on the scale. |
| core.String? lowLabel; |
| |
| ScaleQuestion({ |
| this.high, |
| this.highLabel, |
| this.low, |
| this.lowLabel, |
| }); |
| |
| ScaleQuestion.fromJson(core.Map json_) |
| : this( |
| high: json_.containsKey('high') ? json_['high'] as core.int : null, |
| highLabel: json_.containsKey('highLabel') |
| ? json_['highLabel'] as core.String |
| : null, |
| low: json_.containsKey('low') ? json_['low'] as core.int : null, |
| lowLabel: json_.containsKey('lowLabel') |
| ? json_['lowLabel'] as core.String |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (high != null) 'high': high!, |
| if (highLabel != null) 'highLabel': highLabel!, |
| if (low != null) 'low': low!, |
| if (lowLabel != null) 'lowLabel': lowLabel!, |
| }; |
| } |
| |
| /// An answer to a question represented as text. |
| class TextAnswer { |
| /// The answer value. |
| /// |
| /// Formatting used for different kinds of question: * ChoiceQuestion * |
| /// `RADIO` or `DROP_DOWN`: A single string corresponding to the option that |
| /// was selected. * `CHECKBOX`: Multiple strings corresponding to each option |
| /// that was selected. * TextQuestion: The text that the user entered. * |
| /// ScaleQuestion: A string containing the number that was selected. * |
| /// DateQuestion * Without time or year: MM-DD e.g. "05-19" * With year: |
| /// YYYY-MM-DD e.g. "1986-05-19" * With time: MM-DD HH:MM e.g. "05-19 14:51" * |
| /// With year and time: YYYY-MM-DD HH:MM e.g. "1986-05-19 14:51" * |
| /// TimeQuestion: String with time or duration in HH:MM format e.g. "14:51" * |
| /// RowQuestion within QuestionGroupItem: The answer for each row of a |
| /// QuestionGroupItem is represented as a separate Answer. Each will contain |
| /// one string for `RADIO`-type choices or multiple strings for `CHECKBOX` |
| /// choices. |
| /// |
| /// Output only. |
| core.String? value; |
| |
| TextAnswer({ |
| this.value, |
| }); |
| |
| TextAnswer.fromJson(core.Map json_) |
| : this( |
| value: |
| json_.containsKey('value') ? json_['value'] as core.String : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (value != null) 'value': value!, |
| }; |
| } |
| |
| /// A question's answers as text. |
| class TextAnswers { |
| /// Answers to a question. |
| /// |
| /// For multiple-value ChoiceQuestions, each answer is a separate value. |
| /// |
| /// Output only. |
| core.List<TextAnswer>? answers; |
| |
| TextAnswers({ |
| this.answers, |
| }); |
| |
| TextAnswers.fromJson(core.Map json_) |
| : this( |
| answers: json_.containsKey('answers') |
| ? (json_['answers'] as core.List) |
| .map((value) => TextAnswer.fromJson( |
| value as core.Map<core.String, core.dynamic>)) |
| .toList() |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (answers != null) 'answers': answers!, |
| }; |
| } |
| |
| /// A text item. |
| typedef TextItem = $Empty; |
| |
| /// Link for text. |
| class TextLink { |
| /// Display text for the URI. |
| /// |
| /// Required. |
| core.String? displayText; |
| |
| /// The URI. |
| /// |
| /// Required. |
| core.String? uri; |
| |
| TextLink({ |
| this.displayText, |
| this.uri, |
| }); |
| |
| TextLink.fromJson(core.Map json_) |
| : this( |
| displayText: json_.containsKey('displayText') |
| ? json_['displayText'] as core.String |
| : null, |
| uri: json_.containsKey('uri') ? json_['uri'] as core.String : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (displayText != null) 'displayText': displayText!, |
| if (uri != null) 'uri': uri!, |
| }; |
| } |
| |
| /// A text-based question. |
| class TextQuestion { |
| /// Whether the question is a paragraph question or not. |
| /// |
| /// If not, the question is a short text question. |
| core.bool? paragraph; |
| |
| TextQuestion({ |
| this.paragraph, |
| }); |
| |
| TextQuestion.fromJson(core.Map json_) |
| : this( |
| paragraph: json_.containsKey('paragraph') |
| ? json_['paragraph'] as core.bool |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (paragraph != null) 'paragraph': paragraph!, |
| }; |
| } |
| |
| /// A time question. |
| class TimeQuestion { |
| /// `true` if the question is about an elapsed time. |
| /// |
| /// Otherwise it is about a time of day. |
| core.bool? duration; |
| |
| TimeQuestion({ |
| this.duration, |
| }); |
| |
| TimeQuestion.fromJson(core.Map json_) |
| : this( |
| duration: json_.containsKey('duration') |
| ? json_['duration'] as core.bool |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (duration != null) 'duration': duration!, |
| }; |
| } |
| |
| /// Update Form's Info. |
| class UpdateFormInfoRequest { |
| /// The info to update. |
| Info? info; |
| |
| /// Only values named in this mask are changed. |
| /// |
| /// At least one field must be specified. The root `info` is implied and |
| /// should not be specified. A single `"*"` can be used as short-hand for |
| /// updating every field. |
| /// |
| /// Required. |
| core.String? updateMask; |
| |
| UpdateFormInfoRequest({ |
| this.info, |
| this.updateMask, |
| }); |
| |
| UpdateFormInfoRequest.fromJson(core.Map json_) |
| : this( |
| info: json_.containsKey('info') |
| ? Info.fromJson( |
| json_['info'] as core.Map<core.String, core.dynamic>) |
| : null, |
| updateMask: json_.containsKey('updateMask') |
| ? json_['updateMask'] as core.String |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (info != null) 'info': info!, |
| if (updateMask != null) 'updateMask': updateMask!, |
| }; |
| } |
| |
| /// Update an item in a form. |
| class UpdateItemRequest { |
| /// New values for the item. |
| /// |
| /// Note that item and question IDs are used if they are provided (and are in |
| /// the field mask). If an ID is blank (and in the field mask) a new ID is |
| /// generated. This means you can modify an item by getting the form via |
| /// forms.get, modifying your local copy of that item to be how you want it, |
| /// and using UpdateItemRequest to write it back, with the IDs being the same |
| /// (or not in the field mask). |
| /// |
| /// Required. |
| Item? item; |
| |
| /// The location identifying the item to update. |
| /// |
| /// Required. |
| Location? location; |
| |
| /// Only values named in this mask are changed. |
| /// |
| /// Required. |
| core.String? updateMask; |
| |
| UpdateItemRequest({ |
| this.item, |
| this.location, |
| this.updateMask, |
| }); |
| |
| UpdateItemRequest.fromJson(core.Map json_) |
| : this( |
| item: json_.containsKey('item') |
| ? Item.fromJson( |
| json_['item'] as core.Map<core.String, core.dynamic>) |
| : null, |
| location: json_.containsKey('location') |
| ? Location.fromJson( |
| json_['location'] as core.Map<core.String, core.dynamic>) |
| : null, |
| updateMask: json_.containsKey('updateMask') |
| ? json_['updateMask'] as core.String |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (item != null) 'item': item!, |
| if (location != null) 'location': location!, |
| if (updateMask != null) 'updateMask': updateMask!, |
| }; |
| } |
| |
| /// Update Form's FormSettings. |
| class UpdateSettingsRequest { |
| /// The settings to update with. |
| /// |
| /// Required. |
| FormSettings? settings; |
| |
| /// Only values named in this mask are changed. |
| /// |
| /// At least one field must be specified. The root `settings` is implied and |
| /// should not be specified. A single `"*"` can be used as short-hand for |
| /// updating every field. |
| /// |
| /// Required. |
| core.String? updateMask; |
| |
| UpdateSettingsRequest({ |
| this.settings, |
| this.updateMask, |
| }); |
| |
| UpdateSettingsRequest.fromJson(core.Map json_) |
| : this( |
| settings: json_.containsKey('settings') |
| ? FormSettings.fromJson( |
| json_['settings'] as core.Map<core.String, core.dynamic>) |
| : null, |
| updateMask: json_.containsKey('updateMask') |
| ? json_['updateMask'] as core.String |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (settings != null) 'settings': settings!, |
| if (updateMask != null) 'updateMask': updateMask!, |
| }; |
| } |
| |
| /// Data representing a video. |
| class Video { |
| /// Properties of a video. |
| MediaProperties? properties; |
| |
| /// A YouTube URI. |
| /// |
| /// Required. |
| core.String? youtubeUri; |
| |
| Video({ |
| this.properties, |
| this.youtubeUri, |
| }); |
| |
| Video.fromJson(core.Map json_) |
| : this( |
| properties: json_.containsKey('properties') |
| ? MediaProperties.fromJson( |
| json_['properties'] as core.Map<core.String, core.dynamic>) |
| : null, |
| youtubeUri: json_.containsKey('youtubeUri') |
| ? json_['youtubeUri'] as core.String |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (properties != null) 'properties': properties!, |
| if (youtubeUri != null) 'youtubeUri': youtubeUri!, |
| }; |
| } |
| |
| /// An item containing a video. |
| class VideoItem { |
| /// The text displayed below the video. |
| core.String? caption; |
| |
| /// The video displayed in the item. |
| /// |
| /// Required. |
| Video? video; |
| |
| VideoItem({ |
| this.caption, |
| this.video, |
| }); |
| |
| VideoItem.fromJson(core.Map json_) |
| : this( |
| caption: json_.containsKey('caption') |
| ? json_['caption'] as core.String |
| : null, |
| video: json_.containsKey('video') |
| ? Video.fromJson( |
| json_['video'] as core.Map<core.String, core.dynamic>) |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (caption != null) 'caption': caption!, |
| if (video != null) 'video': video!, |
| }; |
| } |
| |
| /// Link to a video. |
| class VideoLink { |
| /// The display text for the link. |
| /// |
| /// Required. |
| core.String? displayText; |
| |
| /// The URI of a YouTube video. |
| core.String? youtubeUri; |
| |
| VideoLink({ |
| this.displayText, |
| this.youtubeUri, |
| }); |
| |
| VideoLink.fromJson(core.Map json_) |
| : this( |
| displayText: json_.containsKey('displayText') |
| ? json_['displayText'] as core.String |
| : null, |
| youtubeUri: json_.containsKey('youtubeUri') |
| ? json_['youtubeUri'] as core.String |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (displayText != null) 'displayText': displayText!, |
| if (youtubeUri != null) 'youtubeUri': youtubeUri!, |
| }; |
| } |
| |
| /// A watch for events for a form. |
| /// |
| /// When the designated event happens, a notification will be published to the |
| /// specified target. The notification's attributes will include a `formId` key |
| /// that has the ID of the watched form and an `eventType` key that has the |
| /// string of the type. Messages are sent with at-least-once delivery and are |
| /// only dropped in extraordinary circumstances. Typically all notifications |
| /// should be reliably delivered within a few seconds; however, in some |
| /// situations notifications may be delayed. A watch expires seven days after it |
| /// is created unless it is renewed with watches.renew |
| class Watch { |
| /// Timestamp of when this was created. |
| /// |
| /// Output only. |
| core.String? createTime; |
| |
| /// The most recent error type for an attempted delivery. |
| /// |
| /// To begin watching the form again a call can be made to watches.renew which |
| /// also clears this error information. |
| /// |
| /// Output only. |
| /// Possible string values are: |
| /// - "ERROR_TYPE_UNSPECIFIED" : Unspecified error type. |
| /// - "PROJECT_NOT_AUTHORIZED" : The cloud project does not have access to the |
| /// form being watched. This occurs if the user has revoked the authorization |
| /// for your project to access their form(s). Watches with this error will not |
| /// be retried. To attempt to begin watching the form again a call can be made |
| /// to watches.renew |
| /// - "NO_USER_ACCESS" : The user that granted access no longer has access to |
| /// the form being watched. Watches with this error will not be retried. To |
| /// attempt to begin watching the form again a call can be made to |
| /// watches.renew |
| /// - "OTHER_ERRORS" : Another type of error has occurred. Whether |
| /// notifications will continue depends on the watch state. |
| core.String? errorType; |
| |
| /// Which event type to watch for. |
| /// |
| /// Required. |
| /// Possible string values are: |
| /// - "EVENT_TYPE_UNSPECIFIED" : Unspecified event type. This value should not |
| /// be used. |
| /// - "SCHEMA" : The schema event type. A watch with this event type will be |
| /// notified about changes to form content and settings. |
| /// - "RESPONSES" : The responses event type. A watch with this event type |
| /// will be notified when form responses are submitted. |
| core.String? eventType; |
| |
| /// Timestamp for when this will expire. |
| /// |
| /// Each watches.renew call resets this to seven days in the future. |
| /// |
| /// Output only. |
| core.String? expireTime; |
| |
| /// The ID of this watch. |
| /// |
| /// See notes on CreateWatchRequest.watch_id. |
| /// |
| /// Output only. |
| core.String? id; |
| |
| /// The current state of the watch. |
| /// |
| /// Additional details about suspended watches can be found by checking the |
| /// `error_type`. |
| /// |
| /// Output only. |
| /// Possible string values are: |
| /// - "STATE_UNSPECIFIED" : Unspecified state. |
| /// - "ACTIVE" : Watch is active. |
| /// - "SUSPENDED" : The watch is suspended due to an error that may be |
| /// resolved. The watch will continue to exist until it expires. To attempt to |
| /// reactivate the watch a call can be made to watches.renew |
| core.String? state; |
| |
| /// Where to send the notification. |
| /// |
| /// Required. |
| WatchTarget? target; |
| |
| Watch({ |
| this.createTime, |
| this.errorType, |
| this.eventType, |
| this.expireTime, |
| this.id, |
| this.state, |
| this.target, |
| }); |
| |
| Watch.fromJson(core.Map json_) |
| : this( |
| createTime: json_.containsKey('createTime') |
| ? json_['createTime'] as core.String |
| : null, |
| errorType: json_.containsKey('errorType') |
| ? json_['errorType'] as core.String |
| : null, |
| eventType: json_.containsKey('eventType') |
| ? json_['eventType'] as core.String |
| : null, |
| expireTime: json_.containsKey('expireTime') |
| ? json_['expireTime'] as core.String |
| : null, |
| id: json_.containsKey('id') ? json_['id'] as core.String : null, |
| state: |
| json_.containsKey('state') ? json_['state'] as core.String : null, |
| target: json_.containsKey('target') |
| ? WatchTarget.fromJson( |
| json_['target'] as core.Map<core.String, core.dynamic>) |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (createTime != null) 'createTime': createTime!, |
| if (errorType != null) 'errorType': errorType!, |
| if (eventType != null) 'eventType': eventType!, |
| if (expireTime != null) 'expireTime': expireTime!, |
| if (id != null) 'id': id!, |
| if (state != null) 'state': state!, |
| if (target != null) 'target': target!, |
| }; |
| } |
| |
| /// The target for notification delivery. |
| class WatchTarget { |
| /// A Pub/Sub topic. |
| /// |
| /// To receive notifications, the topic must grant publish privileges to the |
| /// Forms service account |
| /// `serviceAccount:forms-notifications@system.gserviceaccount.com`. Only the |
| /// project that owns a topic may create a watch with it. Pub/Sub delivery |
| /// guarantees should be considered. |
| CloudPubsubTopic? topic; |
| |
| WatchTarget({ |
| this.topic, |
| }); |
| |
| WatchTarget.fromJson(core.Map json_) |
| : this( |
| topic: json_.containsKey('topic') |
| ? CloudPubsubTopic.fromJson( |
| json_['topic'] as core.Map<core.String, core.dynamic>) |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (topic != null) 'topic': topic!, |
| }; |
| } |
| |
| /// Provides control over how write requests are executed. |
| class WriteControl { |
| /// The revision ID of the form that the write request is applied to. |
| /// |
| /// If this is not the latest revision of the form, the request is not |
| /// processed and returns a 400 bad request error. |
| core.String? requiredRevisionId; |
| |
| /// The target revision ID of the form that the write request is applied to. |
| /// |
| /// If changes have occurred after this revision, the changes in this update |
| /// request are transformed against those changes. This results in a new |
| /// revision of the form that incorporates both the changes in the request and |
| /// the intervening changes, with the server resolving conflicting changes. |
| /// The target revision ID may only be used to write to recent versions of a |
| /// form. If the target revision is too far behind the latest revision, the |
| /// request is not processed and returns a 400 (Bad Request Error). The |
| /// request may be retried after reading the latest version of the form. In |
| /// most cases a target revision ID remains valid for several minutes after it |
| /// is read, but for frequently-edited forms this window may be shorter. |
| core.String? targetRevisionId; |
| |
| WriteControl({ |
| this.requiredRevisionId, |
| this.targetRevisionId, |
| }); |
| |
| WriteControl.fromJson(core.Map json_) |
| : this( |
| requiredRevisionId: json_.containsKey('requiredRevisionId') |
| ? json_['requiredRevisionId'] as core.String |
| : null, |
| targetRevisionId: json_.containsKey('targetRevisionId') |
| ? json_['targetRevisionId'] as core.String |
| : null, |
| ); |
| |
| core.Map<core.String, core.dynamic> toJson() => { |
| if (requiredRevisionId != null) |
| 'requiredRevisionId': requiredRevisionId!, |
| if (targetRevisionId != null) 'targetRevisionId': targetRevisionId!, |
| }; |
| } |