Definitions for @turbot/gcp-bigquery

{
  "properties": {
    "useAvroLogicalTypes": {
      "description": "[Optional] If sourceFormat is set to \"AVRO\", indicates whether to interpret logical types as the corresponding BigQuery data type (for example, TIMESTAMP), instead of using the raw type (for example, INTEGER).",
      "type": "boolean"
    }
  },
  "type": "object",
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/AvroOptions",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "type": "object",
  "properties": {
    "name": {
      "$ref": "#/definitions/bigqueryName"
    },
    "state": {
      "$ref": "gcp#/definitions/state"
    },
    "config": {
      "type": "object"
    },
    "parent": {
      "type": "string"
    },
    "turbot": {
      "type": "object",
      "properties": {
        "akas": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/bigqueryAka"
          }
        },
        "title": {
          "type": "string"
        },
        "custom": {
          "type": "object",
          "properties": {
            "gcp": {
              "$ref": "gcp#/definitions/gcpMetadata"
            }
          }
        }
      }
    }
  },
  "required": [
    "name"
  ],
  "tests": [
    {
      "description": "Valid - base test",
      "input": {
        "name": "projects/932405488407/services/bigquery.googleapis.com",
        "turbot": {
          "akas": [
            "gcp://serviceusage.googleapis.com/projects/932405488407/services/bigquery.googleapis.com"
          ],
          "title": "BigQuery",
          "custom": {
            "gcp": {
              "projectId": "cse-legolas-2"
            }
          }
        }
      }
    },
    {
      "description": "Invalid - service provider name prefixed",
      "input": {
        "name": "GCP Bigquery",
        "turbot": {
          "akas": [
            "gcp://serviceusage.googleapis.com/projects/932405488407/services/bigquery.googleapis.com"
          ],
          "title": "BigQuery",
          "custom": {
            "gcp": {
              "projectId": "cse-legolas-2"
            }
          }
        }
      },
      "expected": false
    }
  ],
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/bigQuery",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "type": "string",
  "pattern": "^gcp://serviceusage.googleapis.com/projects/[0-9]{12}/services/bigquery.googleapis.com",
  "tests": [
    {
      "description": "base",
      "input": "gcp://serviceusage.googleapis.com/projects/932405488407/services/bigquery.googleapis.com"
    },
    {
      "description": "invalid aka",
      "input": "gcp://serviceusage.googleapis.com/projects/cse-legolas-2/services/bigquery.googleapis.com",
      "expected": false
    }
  ],
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/bigqueryAka",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "type": "string",
  "pattern": "^projects/[0-9]{1,12}/services/bigquery.googleapis.com$",
  "tests": [
    {
      "description": "base",
      "input": "projects/932405488407/services/bigquery.googleapis.com"
    },
    {
      "description": "invalid name",
      "input": "projects/cse-legolas-2/services/iam.googleapis.com",
      "expected": false
    }
  ],
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/bigqueryName",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "type": "array",
  "items": {
    "$ref": "#/definitions/regionName"
  },
  "minItems": 1,
  "example": [
    [
      "asia-east1",
      "us-east4"
    ]
  ],
  "default": [
    "asia-east1",
    "asia-east2",
    "asia-northeast1",
    "asia-south1",
    "asia-southeast1",
    "australia-southeast1",
    "europe-north1",
    "europe-west2",
    "northamerica-northeast1",
    "southamerica-east1",
    "us-east4",
    "us-west2"
  ],
  "tests": [
    {
      "description": "only one region",
      "input": [
        "australia-southeast1"
      ]
    },
    {
      "description": "all supported regions",
      "input": [
        "asia-east1",
        "asia-east2",
        "asia-northeast1",
        "asia-south1",
        "asia-southeast1",
        "australia-southeast1",
        "europe-north1",
        "europe-west2",
        "northamerica-northeast1",
        "southamerica-east1",
        "us-east4",
        "us-west2"
      ]
    },
    {
      "description": "invalid - no regions",
      "input": [],
      "expected": false
    }
  ],
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/bigQuerySupportedRegions",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "properties": {
    "encoding": {
      "description": "[Optional] The encoding of the values when the type is not STRING. Acceptable encoding values are: TEXT - indicates values are alphanumeric text strings. BINARY - indicates values are encoded using HBase Bytes.toBytes family of functions. 'encoding' can also be set at the column family level. However, the setting at this level takes precedence if 'encoding' is set at both levels.",
      "type": "string"
    },
    "fieldName": {
      "description": "[Optional] If the qualifier is not a valid BigQuery field identifier i.e. does not match [a-zA-Z][a-zA-Z0-9_]*, a valid identifier must be provided as the column field name and is used as field name in queries.",
      "type": "string"
    },
    "onlyReadLatest": {
      "description": "[Optional] If this is set, only the latest version of value in this column are exposed. 'onlyReadLatest' can also be set at the column family level. However, the setting at this level takes precedence if 'onlyReadLatest' is set at both levels.",
      "type": "boolean"
    },
    "qualifierEncoded": {
      "description": "[Required] Qualifier of the column. Columns in the parent column family that has this exact qualifier are exposed as . field. If the qualifier is valid UTF-8 string, it can be specified in the qualifier_string field. Otherwise, a base-64 encoded value must be set to qualifier_encoded. The column field name is the same as the column qualifier. However, if the qualifier is not a valid BigQuery field identifier i.e. does not match [a-zA-Z][a-zA-Z0-9_]*, a valid identifier must be provided as field_name.",
      "format": "byte",
      "type": "string"
    },
    "qualifierString": {
      "type": "string"
    },
    "type": {
      "description": "[Optional] The type to convert the value in cells of this column. The values are expected to be encoded using HBase Bytes.toBytes function when using the BINARY encoding value. Following BigQuery types are allowed (case-sensitive) - BYTES STRING INTEGER FLOAT BOOLEAN Default type is BYTES. 'type' can also be set at the column family level. However, the setting at this level takes precedence if 'type' is set at both levels.",
      "type": "string"
    }
  },
  "type": "object",
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/BigtableColumn",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "properties": {
    "columns": {
      "description": "[Optional] Lists of columns that should be exposed as individual fields as opposed to a list of (column name, value) pairs. All columns whose qualifier matches a qualifier in this list can be accessed as .. Other columns can be accessed as a list through .Column field.",
      "items": {
        "$ref": "#/definitions/BigtableColumn"
      },
      "type": "array"
    },
    "encoding": {
      "description": "[Optional] The encoding of the values when the type is not STRING. Acceptable encoding values are: TEXT - indicates values are alphanumeric text strings. BINARY - indicates values are encoded using HBase Bytes.toBytes family of functions. This can be overridden for a specific column by listing that column in 'columns' and specifying an encoding for it.",
      "type": "string"
    },
    "familyId": {
      "description": "Identifier of the column family.",
      "type": "string"
    },
    "onlyReadLatest": {
      "description": "[Optional] If this is set only the latest version of value are exposed for all columns in this column family. This can be overridden for a specific column by listing that column in 'columns' and specifying a different setting for that column.",
      "type": "boolean"
    },
    "type": {
      "description": "[Optional] The type to convert the value in cells of this column family. The values are expected to be encoded using HBase Bytes.toBytes function when using the BINARY encoding value. Following BigQuery types are allowed (case-sensitive) - BYTES STRING INTEGER FLOAT BOOLEAN Default type is BYTES. This can be overridden for a specific column by listing that column in 'columns' and specifying a type for it.",
      "type": "string"
    }
  },
  "type": "object",
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/BigtableColumnFamily",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "properties": {
    "columnFamilies": {
      "description": "[Optional] List of column families to expose in the table schema along with their types. This list restricts the column families that can be referenced in queries and specifies their value types. You can use this list to do type conversions - see the 'type' field for more details. If you leave this list empty, all column families are present in the table schema and their values are read as BYTES. During a query only the column families referenced in that query are read from Bigtable.",
      "items": {
        "$ref": "#/definitions/BigtableColumnFamily"
      },
      "type": "array"
    },
    "ignoreUnspecifiedColumnFamilies": {
      "description": "[Optional] If field is true, then the column families that are not specified in columnFamilies list are not exposed in the table schema. Otherwise, they are read with BYTES type values. The default value is false.",
      "type": "boolean"
    },
    "readRowkeyAsString": {
      "description": "[Optional] If field is true, then the rowkey column families will be read and converted to string. Otherwise they are read with BYTES type values and users need to manually cast them with CAST if necessary. The default value is false.",
      "type": "boolean"
    }
  },
  "type": "object",
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/BigtableOptions",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "properties": {
    "durationMs": {
      "description": "[Output-only, Beta] Time taken to run the training iteration in milliseconds.",
      "format": "int64",
      "type": "string"
    },
    "evalLoss": {
      "description": "[Output-only, Beta] Eval loss computed on the eval data at the end of the iteration. The eval loss is used for early stopping to avoid overfitting. No eval loss if eval_split_method option is specified as no_split or auto_split with input data size less than 500 rows.",
      "format": "double",
      "type": "number"
    },
    "index": {
      "description": "[Output-only, Beta] Index of the ML training iteration, starting from zero for each training run.",
      "format": "int32",
      "type": "integer"
    },
    "learnRate": {
      "description": "[Output-only, Beta] Learning rate used for this iteration, it varies for different training iterations if learn_rate_strategy option is not constant.",
      "format": "double",
      "type": "number"
    },
    "trainingLoss": {
      "description": "[Output-only, Beta] Training loss computed on the training data at the end of the iteration. The training loss function is defined by model type.",
      "format": "double",
      "type": "number"
    }
  },
  "type": "object",
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/BqmlIterationResult",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "properties": {
    "iterationResults": {
      "description": "[Output-only, Beta] List of each iteration results.",
      "items": {
        "$ref": "#/definitions/BqmlIterationResult"
      },
      "type": "array"
    },
    "startTime": {
      "description": "[Output-only, Beta] Training run start time in milliseconds since the epoch.",
      "format": "date-time",
      "type": "string"
    },
    "state": {
      "description": "[Output-only, Beta] Different state applicable for a training run. IN PROGRESS: Training run is in progress. FAILED: Training run ended due to a non-retryable failure. SUCCEEDED: Training run successfully completed. CANCELLED: Training run cancelled by the user.",
      "type": "string"
    },
    "trainingOptions": {
      "description": "[Output-only, Beta] Training options used by this training run. These options are mutable for subsequent training runs. Default values are explicitly stored for options not specified in the input query of the first training run. For subsequent training runs, any option not explicitly specified in the input query will be copied from the previous training run.",
      "properties": {
        "earlyStop": {
          "type": "boolean"
        },
        "l1Reg": {
          "format": "double",
          "type": "number"
        },
        "l2Reg": {
          "format": "double",
          "type": "number"
        },
        "learnRate": {
          "format": "double",
          "type": "number"
        },
        "learnRateStrategy": {
          "type": "string"
        },
        "lineSearchInitLearnRate": {
          "format": "double",
          "type": "number"
        },
        "maxIteration": {
          "format": "int64",
          "type": "string"
        },
        "minRelProgress": {
          "format": "double",
          "type": "number"
        },
        "warmStart": {
          "type": "boolean"
        }
      },
      "type": "object"
    }
  },
  "type": "object",
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/BqmlTrainingRun",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "properties": {
    "baseTableReference": {
      "$ref": "#/definitions/TableReference",
      "description": "[Required] Reference describing the ID of the table that was cloned."
    },
    "cloneTime": {
      "description": "[Required] The time at which the base table was cloned. This value is reported in the JSON response using RFC3339 format.",
      "format": "date-time",
      "type": "string"
    }
  },
  "type": "object",
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/CloneDefinition",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "properties": {
    "fields": {
      "description": "[Repeated] One or more fields on which data should be clustered. Only top-level, non-repeated, simple-type fields are supported. When you cluster a table using multiple columns, the order of columns you specify is important. The order of the specified columns determines the sort order of the data.",
      "items": {
        "type": "string"
      },
      "type": "array"
    }
  },
  "type": "object",
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/Clustering",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "properties": {
    "allowJaggedRows": {
      "description": "[Optional] Indicates if BigQuery should accept rows that are missing trailing optional columns. If true, BigQuery treats missing trailing columns as null values. If false, records with missing trailing columns are treated as bad records, and if there are too many bad records, an invalid error is returned in the job result. The default value is false.",
      "type": "boolean"
    },
    "allowQuotedNewlines": {
      "description": "[Optional] Indicates if BigQuery should allow quoted data sections that contain newline characters in a CSV file. The default value is false.",
      "type": "boolean"
    },
    "encoding": {
      "description": "[Optional] The character encoding of the data. The supported values are UTF-8 or ISO-8859-1. The default value is UTF-8. BigQuery decodes the data after the raw, binary data has been split using the values of the quote and fieldDelimiter properties.",
      "type": "string"
    },
    "fieldDelimiter": {
      "description": "[Optional] The separator for fields in a CSV file. BigQuery converts the string to ISO-8859-1 encoding, and then uses the first byte of the encoded string to split the data in its raw, binary state. BigQuery also supports the escape sequence \"\\t\" to specify a tab separator. The default value is a comma (',').",
      "type": "string"
    },
    "null_marker": {
      "description": "[Optional] An custom string that will represent a NULL value in CSV import data.",
      "type": "string"
    },
    "preserveAsciiControlCharacters": {
      "description": "[Optional] Preserves the embedded ASCII control characters (the first 32 characters in the ASCII-table, from '\\x00' to '\\x1F') when loading from CSV. Only applicable to CSV, ignored for other formats.",
      "type": "boolean"
    },
    "quote": {
      "default": "\"",
      "description": "[Optional] The value that is used to quote data sections in a CSV file. BigQuery converts the string to ISO-8859-1 encoding, and then uses the first byte of the encoded string to split the data in its raw, binary state. The default value is a double-quote ('\"'). If your data does not contain quoted sections, set the property value to an empty string. If your data contains quoted newline characters, you must also set the allowQuotedNewlines property to true.",
      "pattern": ".?",
      "type": "string"
    },
    "skipLeadingRows": {
      "description": "[Optional] The number of rows at the top of a CSV file that BigQuery will skip when reading the data. The default value is 0. This property is useful if you have header rows in the file that should be skipped. When autodetect is on, the behavior is the following: * skipLeadingRows unspecified - Autodetect tries to detect headers in the first row. If they are not detected, the row is read as data. Otherwise data is read starting from the second row. * skipLeadingRows is 0 - Instructs autodetect that there are no headers and data should be read starting from the first row. * skipLeadingRows = N > 0 - Autodetect skips N-1 rows and tries to detect headers in row N. If headers are not detected, row N is just skipped. Otherwise row N is used to extract column names for the detected schema.",
      "format": "int64",
      "type": "string"
    }
  },
  "type": "object",
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/CsvOptions",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "type": "object",
  "properties": {
    "datasetId": {
      "$ref": "#/definitions/id"
    },
    "datasetReference": {
      "type": "object"
    },
    "labels": {
      "$ref": "gcp#/definitions/labels"
    },
    "defaultEncryptionConfiguration": {
      "type": "object",
      "properties": {
        "kmsKeyName": {
          "type": "string"
        }
      }
    },
    "lastUsedTimestamp": {
      "$ref": "turbot#/definitions/isoTimestamp"
    },
    "turbot": {
      "type": "object",
      "properties": {
        "akas": {
          "type": "array",
          "items": {
            "$ref": "#/definitions/datasetAka"
          }
        },
        "title": {
          "$ref": "#/definitions/id"
        },
        "tags": {
          "$ref": "gcp#/definitions/labels"
        },
        "custom": {
          "type": "object",
          "properties": {
            "gcp": {
              "$ref": "gcp#/definitions/gcpMetadata"
            },
            "createTimestamp": {
              "$ref": "turbot#/definitions/isoTimestamp"
            },
            "lastUsedTimestamp": {
              "$ref": "turbot#/definitions/isoTimestamp"
            }
          }
        }
      }
    }
  },
  "required": [
    "datasetReference"
  ],
  "additionalProperties": true,
  "tests": [
    {
      "description": "Valid - All properties",
      "input": {
        "datasetId": "snap_test_123",
        "datasetReference": {
          "datasetId": "snap_test_123",
          "projectId": "123-456"
        },
        "labels": {
          "foo": "bar",
          "foo1": "bar1"
        },
        "turbot": {
          "title": "a123456789a123456789a123456789a123456789a123456789a123456789a12",
          "tags": {
            "foo": "bar",
            "foo1": "bar1"
          },
          "custom": {
            "gcp": {
              "projectId": "123-456"
            }
          }
        }
      }
    },
    {
      "description": "Invalid - Missing  datasetReference",
      "input": {
        "labels": {
          "foo": "bar",
          "foo1": "bar1"
        },
        "turbot": {
          "title": "a123456789a123456789a123456789a123456789a123456789a123456789a12",
          "tags": {
            "foo": "bar",
            "foo1": "bar1"
          },
          "custom": {
            "gcp": {
              "projectId": "123-456"
            }
          }
        }
      },
      "expected": false
    }
  ],
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/dataset",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "properties": {
    "access": {
      "description": "[Optional] An array of objects that define dataset access for one or more entities. You can set this property when inserting or updating a dataset in order to control who is allowed to access the data. If unspecified at dataset creation time, BigQuery adds default dataset access for the following entities: access.specialGroup: projectReaders; access.role: READER; access.specialGroup: projectWriters; access.role: WRITER; access.specialGroup: projectOwners; access.role: OWNER; access.userByEmail: [dataset creator email]; access.role: OWNER;",
      "items": {
        "properties": {
          "dataset": {
            "$ref": "#/definitions/DatasetAccessEntry",
            "description": "[Pick one] A grant authorizing all resources of a particular type in a particular dataset access to this dataset. Only views are supported for now. The role field is not required when this field is set. If that dataset is deleted and re-created, its access needs to be granted again via an update operation."
          },
          "domain": {
            "description": "[Pick one] A domain to grant access to. Any users signed in with the domain specified will be granted the specified access. Example: \"example.com\". Maps to IAM policy member \"domain:DOMAIN\".",
            "type": "string"
          },
          "groupByEmail": {
            "description": "[Pick one] An email address of a Google Group to grant access to. Maps to IAM policy member \"group:GROUP\".",
            "type": "string"
          },
          "iamMember": {
            "description": "[Pick one] Some other type of member that appears in the IAM Policy but isn't a user, group, domain, or special group.",
            "type": "string"
          },
          "role": {
            "description": "[Required] An IAM role ID that should be granted to the user, group, or domain specified in this access entry. The following legacy mappings will be applied: OWNER  roles/bigquery.dataOwner WRITER  roles/bigquery.dataEditor READER  roles/bigquery.dataViewer This field will accept any of the above formats, but will return only the legacy format. For example, if you set this field to \"roles/bigquery.dataOwner\", it will be returned back as \"OWNER\".",
            "type": "string"
          },
          "routine": {
            "$ref": "#/definitions/RoutineReference",
            "description": "[Pick one] A routine from a different dataset to grant access to. Queries executed against that routine will have read access to views/tables/routines in this dataset. Only UDF is supported for now. The role field is not required when this field is set. If that routine is updated by any user, access to the routine needs to be granted again via an update operation."
          },
          "specialGroup": {
            "description": "[Pick one] A special group to grant access to. Possible values include: projectOwners: Owners of the enclosing project. projectReaders: Readers of the enclosing project. projectWriters: Writers of the enclosing project. allAuthenticatedUsers: All authenticated BigQuery users. Maps to similarly-named IAM members.",
            "type": "string"
          },
          "userByEmail": {
            "description": "[Pick one] An email address of a user to grant access to. For example: fred@example.com. Maps to IAM policy member \"user:EMAIL\" or \"serviceAccount:EMAIL\".",
            "type": "string"
          },
          "view": {
            "$ref": "#/definitions/TableReference",
            "description": "[Pick one] A view from a different dataset to grant access to. Queries executed against that view will have read access to tables in this dataset. The role field is not required when this field is set. If that view is updated by any user, access to the view needs to be granted again via an update operation."
          }
        },
        "type": "object"
      },
      "type": "array"
    },
    "creationTime": {
      "description": "[Output-only] The time when this dataset was created, in milliseconds since the epoch.",
      "format": "int64",
      "type": "string"
    },
    "datasetReference": {
      "$ref": "#/definitions/DatasetReference",
      "description": "[Required] A reference that identifies the dataset."
    },
    "defaultCollation": {
      "description": "[Output-only] The default collation of the dataset.",
      "type": "string"
    },
    "defaultEncryptionConfiguration": {
      "$ref": "#/definitions/EncryptionConfiguration"
    },
    "defaultPartitionExpirationMs": {
      "description": "[Optional] The default partition expiration for all partitioned tables in the dataset, in milliseconds. Once this property is set, all newly-created partitioned tables in the dataset will have an expirationMs property in the timePartitioning settings set to this value, and changing the value will only affect new tables, not existing ones. The storage in a partition will have an expiration time of its partition time plus this value. Setting this property overrides the use of defaultTableExpirationMs for partitioned tables: only one of defaultTableExpirationMs and defaultPartitionExpirationMs will be used for any new partitioned table. If you provide an explicit timePartitioning.expirationMs when creating or updating a partitioned table, that value takes precedence over the default partition expiration time indicated by this property.",
      "format": "int64",
      "type": "string"
    },
    "defaultRoundingMode": {
      "description": "[Output-only] The default rounding mode of the dataset.",
      "type": "string"
    },
    "defaultTableExpirationMs": {
      "description": "[Optional] The default lifetime of all tables in the dataset, in milliseconds. The minimum value is 3600000 milliseconds (one hour). Once this property is set, all newly-created tables in the dataset will have an expirationTime property set to the creation time plus the value in this property, and changing the value will only affect new tables, not existing ones. When the expirationTime for a given table is reached, that table will be deleted automatically. If a table's expirationTime is modified or removed before the table expires, or if you provide an explicit expirationTime when creating a table, that value takes precedence over the default expiration time indicated by this property.",
      "format": "int64",
      "type": "string"
    },
    "description": {
      "description": "[Optional] A user-friendly description of the dataset.",
      "type": "string"
    },
    "etag": {
      "description": "[Output-only] A hash of the resource.",
      "type": "string"
    },
    "friendlyName": {
      "description": "[Optional] A descriptive name for the dataset.",
      "type": "string"
    },
    "id": {
      "description": "[Output-only] The fully-qualified unique name of the dataset in the format projectId:datasetId. The dataset name without the project name is given in the datasetId field. When creating a new dataset, leave this field blank, and instead specify the datasetId field.",
      "type": "string"
    },
    "isCaseInsensitive": {
      "description": "[Optional] Indicates if table names are case insensitive in the dataset.",
      "type": "boolean"
    },
    "kind": {
      "default": "bigquery#dataset",
      "description": "[Output-only] The resource type.",
      "type": "string"
    },
    "labels": {
      "additionalProperties": {
        "type": "string"
      },
      "description": "The labels associated with this dataset. You can use these to organize and group your datasets. You can set this property when inserting or updating a dataset. See Creating and Updating Dataset Labels for more information.",
      "type": "object"
    },
    "lastModifiedTime": {
      "description": "[Output-only] The date when this dataset or any of its tables was last modified, in milliseconds since the epoch.",
      "format": "int64",
      "type": "string"
    },
    "location": {
      "description": "The geographic location where the dataset should reside. The default value is US. See details at https://cloud.google.com/bigquery/docs/locations.",
      "type": "string"
    },
    "maxTimeTravelHours": {
      "description": "[Optional] Number of hours for the max time travel for all tables in the dataset.",
      "format": "int64",
      "type": "string"
    },
    "satisfiesPzs": {
      "description": "[Output-only] Reserved for future use.",
      "type": "boolean"
    },
    "selfLink": {
      "description": "[Output-only] A URL that can be used to access the resource again. You can use this URL in Get or Update requests to the resource.",
      "type": "string"
    },
    "storageBillingModel": {
      "description": "[Optional] Storage billing model to be used for all tables in the dataset. Can be set to PHYSICAL. Default is LOGICAL.",
      "type": "string"
    },
    "tags": {
      "description": "[Optional]The tags associated with this dataset. Tag keys are globally unique.",
      "items": {
        "properties": {
          "tagKey": {
            "description": "[Required] The namespaced friendly name of the tag key, e.g. \"12345/environment\" where 12345 is org id.",
            "type": "string"
          },
          "tagValue": {
            "description": "[Required] Friendly short name of the tag value, e.g. \"production\".",
            "type": "string"
          }
        },
        "type": "object"
      },
      "type": "array"
    }
  },
  "type": "object",
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/Dataset",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "properties": {
    "dataset": {
      "$ref": "#/definitions/DatasetReference",
      "description": "[Required] The dataset this entry applies to."
    },
    "targetTypes": {
      "items": {
        "enum": [
          "TARGET_TYPE_UNSPECIFIED",
          "VIEWS",
          "ROUTINES"
        ],
        "type": "string"
      },
      "type": "array"
    }
  },
  "type": "object",
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/DatasetAccessEntry",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "type": "string",
  "pattern": "^gcp://bigquery.googleapis.com/projects/[a-z0-9-]{5,29}[a-z0-9]{1}/datasets/[-a-zA-Z0-9_]{1,1024}$",
  "tests": [
    {
      "descritpion": "base case",
      "input": "gcp://bigquery.googleapis.com/projects/aar-a4b6d489/datasets/snap-_test_123"
    },
    {
      "description": "invalid - invalid id",
      "input": "gcp://bigquery.googleapis.com/projects/aar-a4b6d489/datasets/test01*-",
      "expected": false
    }
  ],
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/datasetAka",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "properties": {
    "datasetId": {
      "description": "[Required] A unique ID for this dataset, without the project name. The ID must contain only letters (a-z, A-Z), numbers (0-9), or underscores (_). The maximum length is 1,024 characters.",
      "type": "string"
    },
    "projectId": {
      "description": "[Optional] The ID of the project containing this dataset.",
      "type": "string"
    }
  },
  "type": "object",
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/DatasetReference",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "type": "object",
  "properties": {
    "kmsKeyName": {
      "$ref": "#/definitions/kmskeyname"
    }
  },
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/encryptConfiguration",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "properties": {
    "kmsKeyName": {
      "description": "Optional. Describes the Cloud KMS encryption key that will be used to protect destination BigQuery table. The BigQuery Service Account associated with your project requires access to this encryption key.",
      "type": "string"
    }
  },
  "type": "object",
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/EncryptionConfiguration",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "properties": {
    "autodetect": {
      "description": "Try to detect schema and format options automatically. Any option specified explicitly will be honored.",
      "type": "boolean"
    },
    "avroOptions": {
      "$ref": "#/definitions/AvroOptions",
      "description": "Additional properties to set if sourceFormat is set to Avro."
    },
    "bigtableOptions": {
      "$ref": "#/definitions/BigtableOptions",
      "description": "[Optional] Additional options if sourceFormat is set to BIGTABLE."
    },
    "compression": {
      "description": "[Optional] The compression type of the data source. Possible values include GZIP and NONE. The default value is NONE. This setting is ignored for Google Cloud Bigtable, Google Cloud Datastore backups and Avro formats.",
      "type": "string"
    },
    "connectionId": {
      "description": "[Optional, Trusted Tester] Connection for external data source.",
      "type": "string"
    },
    "csvOptions": {
      "$ref": "#/definitions/CsvOptions",
      "description": "Additional properties to set if sourceFormat is set to CSV."
    },
    "decimalTargetTypes": {
      "description": "[Optional] Defines the list of possible SQL data types to which the source decimal values are converted. This list and the precision and the scale parameters of the decimal field determine the target type. In the order of NUMERIC, BIGNUMERIC, and STRING, a type is picked if it is in the specified list and if it supports the precision and the scale. STRING supports all precision and scale values. If none of the listed types supports the precision and the scale, the type supporting the widest range in the specified list is picked, and if a value exceeds the supported range when reading the data, an error will be thrown. Example: Suppose the value of this field is [\"NUMERIC\", \"BIGNUMERIC\"]. If (precision,scale) is: (38,9) -> NUMERIC; (39,9) -> BIGNUMERIC (NUMERIC cannot hold 30 integer digits); (38,10) -> BIGNUMERIC (NUMERIC cannot hold 10 fractional digits); (76,38) -> BIGNUMERIC; (77,38) -> BIGNUMERIC (error if value exeeds supported range). This field cannot contain duplicate types. The order of the types in this field is ignored. For example, [\"BIGNUMERIC\", \"NUMERIC\"] is the same as [\"NUMERIC\", \"BIGNUMERIC\"] and NUMERIC always takes precedence over BIGNUMERIC. Defaults to [\"NUMERIC\", \"STRING\"] for ORC and [\"NUMERIC\"] for the other file formats.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "fileSetSpecType": {
      "description": "[Optional] Specifies how source URIs are interpreted for constructing the file set to load. By default source URIs are expanded against the underlying storage. Other options include specifying manifest files. Only applicable to object storage systems.",
      "type": "string"
    },
    "googleSheetsOptions": {
      "$ref": "#/definitions/GoogleSheetsOptions",
      "description": "[Optional] Additional options if sourceFormat is set to GOOGLE_SHEETS."
    },
    "hivePartitioningOptions": {
      "$ref": "#/definitions/HivePartitioningOptions",
      "description": "[Optional] Options to configure hive partitioning support."
    },
    "ignoreUnknownValues": {
      "description": "[Optional] Indicates if BigQuery should allow extra values that are not represented in the table schema. If true, the extra values are ignored. If false, records with extra columns are treated as bad records, and if there are too many bad records, an invalid error is returned in the job result. The default value is false. The sourceFormat property determines what BigQuery treats as an extra value: CSV: Trailing columns JSON: Named values that don't match any column names Google Cloud Bigtable: This setting is ignored. Google Cloud Datastore backups: This setting is ignored. Avro: This setting is ignored.",
      "type": "boolean"
    },
    "jsonOptions": {
      "$ref": "#/definitions/JsonOptions",
      "description": "Additional properties to set if `sourceFormat` is set to `NEWLINE_DELIMITED_JSON`."
    },
    "maxBadRecords": {
      "description": "[Optional] The maximum number of bad records that BigQuery can ignore when reading data. If the number of bad records exceeds this value, an invalid error is returned in the job result. This is only valid for CSV, JSON, and Google Sheets. The default value is 0, which requires that all records are valid. This setting is ignored for Google Cloud Bigtable, Google Cloud Datastore backups and Avro formats.",
      "format": "int32",
      "type": "integer"
    },
    "metadataCacheMode": {
      "description": "[Optional] Metadata Cache Mode for the table. Set this to enable caching of metadata from external data source.",
      "type": "string"
    },
    "objectMetadata": {
      "description": "ObjectMetadata is used to create Object Tables. Object Tables contain a listing of objects (with their metadata) found at the source_uris. If ObjectMetadata is set, source_format should be omitted. Currently SIMPLE is the only supported Object Metadata type.",
      "type": "string"
    },
    "parquetOptions": {
      "$ref": "#/definitions/ParquetOptions",
      "description": "Additional properties to set if sourceFormat is set to Parquet."
    },
    "referenceFileSchemaUri": {
      "description": "[Optional] Provide a referencing file with the expected table schema. Enabled for the format: AVRO, PARQUET, ORC.",
      "type": "string"
    },
    "schema": {
      "$ref": "#/definitions/TableSchema",
      "description": "[Optional] The schema for the data. Schema is required for CSV and JSON formats. Schema is disallowed for Google Cloud Bigtable, Cloud Datastore backups, and Avro formats."
    },
    "sourceFormat": {
      "description": "[Required] The data format. For CSV files, specify \"CSV\". For Google sheets, specify \"GOOGLE_SHEETS\". For newline-delimited JSON, specify \"NEWLINE_DELIMITED_JSON\". For Avro files, specify \"AVRO\". For Google Cloud Datastore backups, specify \"DATASTORE_BACKUP\". [Beta] For Google Cloud Bigtable, specify \"BIGTABLE\".",
      "type": "string"
    },
    "sourceUris": {
      "description": "[Required] The fully-qualified URIs that point to your data in Google Cloud. For Google Cloud Storage URIs: Each URI can contain one '*' wildcard character and it must come after the 'bucket' name. Size limits related to load jobs apply to external data sources. For Google Cloud Bigtable URIs: Exactly one URI can be specified and it has be a fully specified and valid HTTPS URL for a Google Cloud Bigtable table. For Google Cloud Datastore backups, exactly one URI can be specified. Also, the '*' wildcard character is not allowed.",
      "items": {
        "type": "string"
      },
      "type": "array"
    }
  },
  "type": "object",
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/ExternalDataConfiguration",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "properties": {
    "range": {
      "description": "[Optional] Range of a sheet to query from. Only used when non-empty. Typical format: sheet_name!top_left_cell_id:bottom_right_cell_id For example: sheet1!A1:B20",
      "type": "string"
    },
    "skipLeadingRows": {
      "description": "[Optional] The number of rows at the top of a sheet that BigQuery will skip when reading the data. The default value is 0. This property is useful if you have header rows that should be skipped. When autodetect is on, behavior is the following: * skipLeadingRows unspecified - Autodetect tries to detect headers in the first row. If they are not detected, the row is read as data. Otherwise data is read starting from the second row. * skipLeadingRows is 0 - Instructs autodetect that there are no headers and data should be read starting from the first row. * skipLeadingRows = N > 0 - Autodetect skips N-1 rows and tries to detect headers in row N. If headers are not detected, row N is just skipped. Otherwise row N is used to extract column names for the detected schema.",
      "format": "int64",
      "type": "string"
    }
  },
  "type": "object",
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/GoogleSheetsOptions",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "properties": {
    "fields": {
      "description": "[Output-only] For permanent external tables, this field is populated with the hive partition keys in the order they were inferred. The types of the partition keys can be deduced by checking the table schema (which will include the partition keys). Not every API will populate this field in the output. For example, Tables.Get will populate it, but Tables.List will not contain this field.",
      "items": {
        "type": "string"
      },
      "type": "array"
    },
    "mode": {
      "description": "[Optional] When set, what mode of hive partitioning to use when reading data. The following modes are supported. (1) AUTO: automatically infer partition key name(s) and type(s). (2) STRINGS: automatically infer partition key name(s). All types are interpreted as strings. (3) CUSTOM: partition key schema is encoded in the source URI prefix. Not all storage formats support hive partitioning. Requesting hive partitioning on an unsupported format will lead to an error. Currently supported types include: AVRO, CSV, JSON, ORC and Parquet.",
      "type": "string"
    },
    "requirePartitionFilter": {
      "description": "[Optional] If set to true, queries over this table require a partition filter that can be used for partition elimination to be specified. Note that this field should only be true when creating a permanent external table or querying a temporary external table. Hive-partitioned loads with requirePartitionFilter explicitly set to true will fail.",
      "type": "boolean"
    },
    "sourceUriPrefix": {
      "description": "[Optional] When hive partition detection is requested, a common prefix for all source uris should be supplied. The prefix must end immediately before the partition key encoding begins. For example, consider files following this data layout. gs://bucket/path_to_table/dt=2019-01-01/country=BR/id=7/file.avro gs://bucket/path_to_table/dt=2018-12-31/country=CA/id=3/file.avro When hive partitioning is requested with either AUTO or STRINGS detection, the common prefix can be either of gs://bucket/path_to_table or gs://bucket/path_to_table/ (trailing slash does not matter).",
      "type": "string"
    }
  },
  "type": "object",
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/HivePartitioningOptions",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "type": "string",
  "pattern": "^[a-zA-Z0-9_]{1,1024}$",
  "tests": [
    {
      "input": "test_dataset"
    },
    {
      "input": "a123456789a123456789a123456789a123456789a123456789a123456789a12"
    },
    {
      "description": "invalid - cannot contain any special character",
      "input": "snap_test%123",
      "expected": false
    },
    {
      "description": "invalid - empty string passed",
      "input": "",
      "expected": false
    }
  ],
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/id",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "properties": {
    "encoding": {
      "description": "[Optional] The character encoding of the data. The supported values are UTF-8, UTF-16BE, UTF-16LE, UTF-32BE, and UTF-32LE. The default value is UTF-8.",
      "type": "string"
    }
  },
  "type": "object",
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/JsonOptions",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "type": "string",
  "tests": [
    {
      "description": "valid case",
      "input": "projects/cse-legolas/locations/global/keyRings/test/cryptoKeys/disk/cryptoKeyVersions/1"
    },
    {
      "description": "invalid - encryption cannot contains array",
      "input": [],
      "expected": false
    }
  ],
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/kmskeyname",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "properties": {
    "allow_non_incremental_definition": {
      "description": "[Optional] Allow non incremental materialized view definition. The default value is \"false\".",
      "type": "boolean"
    },
    "enableRefresh": {
      "description": "[Optional] [TrustedTester] Enable automatic refresh of the materialized view when the base table is updated. The default value is \"true\".",
      "type": "boolean"
    },
    "lastRefreshTime": {
      "description": "[Output-only] [TrustedTester] The time when this materialized view was last modified, in milliseconds since the epoch.",
      "format": "int64",
      "type": "string"
    },
    "maxStaleness": {
      "description": "[Optional] Max staleness of data that could be returned when materizlized view is queried (formatted as Google SQL Interval type).",
      "format": "byte",
      "type": "string"
    },
    "query": {
      "description": "[Required] A query whose result is persisted.",
      "type": "string"
    },
    "refreshIntervalMs": {
      "description": "[Optional] [TrustedTester] The maximum frequency at which this materialized view will be refreshed. The default value is \"1800000\" (30 minutes).",
      "format": "int64",
      "type": "string"
    }
  },
  "type": "object",
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/MaterializedViewDefinition",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "properties": {
    "modelOptions": {
      "description": "[Output-only, Beta] Model options used for the first training run. These options are immutable for subsequent training runs. Default values are used for any options not specified in the input query.",
      "properties": {
        "labels": {
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "lossType": {
          "type": "string"
        },
        "modelType": {
          "type": "string"
        }
      },
      "type": "object"
    },
    "trainingRuns": {
      "description": "[Output-only, Beta] Information about ml training runs, each training run comprises of multiple iterations and there may be multiple training runs for the model if warm start is used or if a user decides to continue a previously cancelled query.",
      "items": {
        "$ref": "#/definitions/BqmlTrainingRun"
      },
      "type": "array"
    }
  },
  "type": "object",
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/ModelDefinition",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "properties": {
    "enableListInference": {
      "description": "[Optional] Indicates whether to use schema inference specifically for Parquet LIST logical type.",
      "type": "boolean"
    },
    "enumAsString": {
      "description": "[Optional] Indicates whether to infer Parquet ENUM logical type as STRING instead of BYTES by default.",
      "type": "boolean"
    }
  },
  "type": "object",
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/ParquetOptions",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "properties": {
    "field": {
      "description": "[TrustedTester] [Required] The table is partitioned by this field. The field must be a top-level NULLABLE/REQUIRED field. The only supported type is INTEGER/INT64.",
      "type": "string"
    },
    "range": {
      "description": "[TrustedTester] [Required] Defines the ranges for range partitioning.",
      "properties": {
        "end": {
          "description": "[TrustedTester] [Required] The end of range partitioning, exclusive.",
          "format": "int64",
          "type": "string"
        },
        "interval": {
          "description": "[TrustedTester] [Required] The width of each interval.",
          "format": "int64",
          "type": "string"
        },
        "start": {
          "description": "[TrustedTester] [Required] The start of range partitioning, inclusive.",
          "format": "int64",
          "type": "string"
        }
      },
      "type": "object"
    }
  },
  "type": "object",
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/RangePartitioning",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "type": "string",
  "enum": [
    "asia-east1",
    "asia-east2",
    "asia-northeast1",
    "asia-south1",
    "asia-southeast1",
    "australia-southeast1",
    "europe-north1",
    "europe-west2",
    "northamerica-northeast1",
    "southamerica-east1",
    "us-east4",
    "us-west2"
  ],
  "tests": [
    {
      "description": "valid",
      "input": "us-east4"
    },
    {
      "description": "invalid - region",
      "input": "us-eass1",
      "expected": false
    },
    {
      "description": "invalid - unsupported region",
      "input": "us-west1",
      "expected": false
    }
  ],
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/regionName",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "properties": {
    "datasetId": {
      "description": "Required. The ID of the dataset containing this routine.",
      "type": "string"
    },
    "projectId": {
      "description": "Required. The ID of the project containing this routine.",
      "type": "string"
    },
    "routineId": {
      "description": "Required. The ID of the routine. The ID must contain only letters (a-z, A-Z), numbers (0-9), or underscores (_). The maximum length is 256 characters.",
      "type": "string"
    }
  },
  "type": "object",
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/RoutineReference",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}

{
  "properties": {
    "baseTableReference": {
      "$ref": "#/definitions/TableReference",
      "description": "[Required] Reference describing the ID of the table that was snapshot."
    },
    "snapshotTime": {
      "description": "[Required] The time at which the base table was snapshot. This value is reported in the JSON response using RFC3339 format.",
      "format": "date-time",
      "type": "string"
    }
  },
  "type": "object",
  ".turbot": {
    "uri": "tmod:@turbot/gcp-bigquery#/definitions/SnapshotDefinition",
    "modUri": "tmod:@turbot/gcp-bigquery"
  }
}