@googleapis/dataform 7.2.0 → 9.0.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +43 -0
- package/build/index.d.ts +1 -1
- package/build/index.js.map +1 -1
- package/build/v1beta1.d.ts +3788 -126
- package/build/v1beta1.js.map +1 -1
- package/index.ts +0 -1
- package/package.json +2 -2
- package/v1beta1.ts +3984 -227
package/build/v1beta1.d.ts
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
/// <reference types="node" />
|
|
2
|
-
import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient,
|
|
2
|
+
import { OAuth2Client, JWT, Compute, UserRefreshClient, BaseExternalAccountClient, GaxiosResponseWithHTTP2, GoogleConfigurable, MethodOptions, StreamMethodOptions, GlobalOptions, GoogleAuth, BodyResponseCallback, APIRequestContext } from 'googleapis-common';
|
|
3
3
|
import { Readable } from 'stream';
|
|
4
4
|
export declare namespace dataform_v1beta1 {
|
|
5
5
|
export interface Options extends GlobalOptions {
|
|
@@ -1076,6 +1076,10 @@ export declare namespace dataform_v1beta1 {
|
|
|
1076
1076
|
* Configures various aspects of Dataform notebook runtime.
|
|
1077
1077
|
*/
|
|
1078
1078
|
export interface Schema$NotebookRuntimeOptions {
|
|
1079
|
+
/**
|
|
1080
|
+
* Optional. The resource name of the [Colab runtime template] (https://cloud.google.com/colab/docs/runtimes), from which a runtime is created for notebook executions. If not specified, a runtime is created with Colab's default specifications.
|
|
1081
|
+
*/
|
|
1082
|
+
aiPlatformNotebookRuntimeTemplate?: string | null;
|
|
1079
1083
|
/**
|
|
1080
1084
|
* Optional. The Google Cloud Storage location to upload the result to. Format: `gs://bucket-name`.
|
|
1081
1085
|
*/
|
|
@@ -1860,56 +1864,278 @@ export declare namespace dataform_v1beta1 {
|
|
|
1860
1864
|
constructor(context: APIRequestContext);
|
|
1861
1865
|
/**
|
|
1862
1866
|
* Gets information about a location.
|
|
1867
|
+
* @example
|
|
1868
|
+
* ```js
|
|
1869
|
+
* // Before running the sample:
|
|
1870
|
+
* // - Enable the API at:
|
|
1871
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
1872
|
+
* // - Login into gcloud by running:
|
|
1873
|
+
* // ```sh
|
|
1874
|
+
* // $ gcloud auth application-default login
|
|
1875
|
+
* // ```
|
|
1876
|
+
* // - Install the npm module by running:
|
|
1877
|
+
* // ```sh
|
|
1878
|
+
* // $ npm install googleapis
|
|
1879
|
+
* // ```
|
|
1880
|
+
*
|
|
1881
|
+
* const {google} = require('googleapis');
|
|
1882
|
+
* const dataform = google.dataform('v1beta1');
|
|
1883
|
+
*
|
|
1884
|
+
* async function main() {
|
|
1885
|
+
* const auth = new google.auth.GoogleAuth({
|
|
1886
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
1887
|
+
* scopes: [
|
|
1888
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
1889
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
1890
|
+
* ],
|
|
1891
|
+
* });
|
|
1892
|
+
*
|
|
1893
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
1894
|
+
* const authClient = await auth.getClient();
|
|
1895
|
+
* google.options({auth: authClient});
|
|
1896
|
+
*
|
|
1897
|
+
* // Do the magic
|
|
1898
|
+
* const res = await dataform.projects.locations.get({
|
|
1899
|
+
* // Resource name for the location.
|
|
1900
|
+
* name: 'projects/my-project/locations/my-location',
|
|
1901
|
+
* });
|
|
1902
|
+
* console.log(res.data);
|
|
1903
|
+
*
|
|
1904
|
+
* // Example response
|
|
1905
|
+
* // {
|
|
1906
|
+
* // "displayName": "my_displayName",
|
|
1907
|
+
* // "labels": {},
|
|
1908
|
+
* // "locationId": "my_locationId",
|
|
1909
|
+
* // "metadata": {},
|
|
1910
|
+
* // "name": "my_name"
|
|
1911
|
+
* // }
|
|
1912
|
+
* }
|
|
1913
|
+
*
|
|
1914
|
+
* main().catch(e => {
|
|
1915
|
+
* console.error(e);
|
|
1916
|
+
* throw e;
|
|
1917
|
+
* });
|
|
1918
|
+
*
|
|
1919
|
+
* ```
|
|
1863
1920
|
*
|
|
1864
1921
|
* @param params - Parameters for request
|
|
1865
1922
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
1866
1923
|
* @param callback - Optional callback that handles the response.
|
|
1867
1924
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
1868
1925
|
*/
|
|
1869
|
-
get(params: Params$Resource$Projects$Locations$Get, options: StreamMethodOptions):
|
|
1870
|
-
get(params?: Params$Resource$Projects$Locations$Get, options?: MethodOptions):
|
|
1926
|
+
get(params: Params$Resource$Projects$Locations$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
1927
|
+
get(params?: Params$Resource$Projects$Locations$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Location>>;
|
|
1871
1928
|
get(params: Params$Resource$Projects$Locations$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
1872
1929
|
get(params: Params$Resource$Projects$Locations$Get, options: MethodOptions | BodyResponseCallback<Schema$Location>, callback: BodyResponseCallback<Schema$Location>): void;
|
|
1873
1930
|
get(params: Params$Resource$Projects$Locations$Get, callback: BodyResponseCallback<Schema$Location>): void;
|
|
1874
1931
|
get(callback: BodyResponseCallback<Schema$Location>): void;
|
|
1875
1932
|
/**
|
|
1876
1933
|
* Get default config for a given project and location.
|
|
1934
|
+
* @example
|
|
1935
|
+
* ```js
|
|
1936
|
+
* // Before running the sample:
|
|
1937
|
+
* // - Enable the API at:
|
|
1938
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
1939
|
+
* // - Login into gcloud by running:
|
|
1940
|
+
* // ```sh
|
|
1941
|
+
* // $ gcloud auth application-default login
|
|
1942
|
+
* // ```
|
|
1943
|
+
* // - Install the npm module by running:
|
|
1944
|
+
* // ```sh
|
|
1945
|
+
* // $ npm install googleapis
|
|
1946
|
+
* // ```
|
|
1947
|
+
*
|
|
1948
|
+
* const {google} = require('googleapis');
|
|
1949
|
+
* const dataform = google.dataform('v1beta1');
|
|
1950
|
+
*
|
|
1951
|
+
* async function main() {
|
|
1952
|
+
* const auth = new google.auth.GoogleAuth({
|
|
1953
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
1954
|
+
* scopes: [
|
|
1955
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
1956
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
1957
|
+
* ],
|
|
1958
|
+
* });
|
|
1959
|
+
*
|
|
1960
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
1961
|
+
* const authClient = await auth.getClient();
|
|
1962
|
+
* google.options({auth: authClient});
|
|
1963
|
+
*
|
|
1964
|
+
* // Do the magic
|
|
1965
|
+
* const res = await dataform.projects.locations.getConfig({
|
|
1966
|
+
* // Required. The config name.
|
|
1967
|
+
* name: 'projects/my-project/locations/my-location/config',
|
|
1968
|
+
* });
|
|
1969
|
+
* console.log(res.data);
|
|
1970
|
+
*
|
|
1971
|
+
* // Example response
|
|
1972
|
+
* // {
|
|
1973
|
+
* // "defaultKmsKeyName": "my_defaultKmsKeyName",
|
|
1974
|
+
* // "name": "my_name"
|
|
1975
|
+
* // }
|
|
1976
|
+
* }
|
|
1977
|
+
*
|
|
1978
|
+
* main().catch(e => {
|
|
1979
|
+
* console.error(e);
|
|
1980
|
+
* throw e;
|
|
1981
|
+
* });
|
|
1982
|
+
*
|
|
1983
|
+
* ```
|
|
1877
1984
|
*
|
|
1878
1985
|
* @param params - Parameters for request
|
|
1879
1986
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
1880
1987
|
* @param callback - Optional callback that handles the response.
|
|
1881
1988
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
1882
1989
|
*/
|
|
1883
|
-
getConfig(params: Params$Resource$Projects$Locations$Getconfig, options: StreamMethodOptions):
|
|
1884
|
-
getConfig(params?: Params$Resource$Projects$Locations$Getconfig, options?: MethodOptions):
|
|
1990
|
+
getConfig(params: Params$Resource$Projects$Locations$Getconfig, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
1991
|
+
getConfig(params?: Params$Resource$Projects$Locations$Getconfig, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Config>>;
|
|
1885
1992
|
getConfig(params: Params$Resource$Projects$Locations$Getconfig, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
1886
1993
|
getConfig(params: Params$Resource$Projects$Locations$Getconfig, options: MethodOptions | BodyResponseCallback<Schema$Config>, callback: BodyResponseCallback<Schema$Config>): void;
|
|
1887
1994
|
getConfig(params: Params$Resource$Projects$Locations$Getconfig, callback: BodyResponseCallback<Schema$Config>): void;
|
|
1888
1995
|
getConfig(callback: BodyResponseCallback<Schema$Config>): void;
|
|
1889
1996
|
/**
|
|
1890
1997
|
* Lists information about the supported locations for this service.
|
|
1998
|
+
* @example
|
|
1999
|
+
* ```js
|
|
2000
|
+
* // Before running the sample:
|
|
2001
|
+
* // - Enable the API at:
|
|
2002
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
2003
|
+
* // - Login into gcloud by running:
|
|
2004
|
+
* // ```sh
|
|
2005
|
+
* // $ gcloud auth application-default login
|
|
2006
|
+
* // ```
|
|
2007
|
+
* // - Install the npm module by running:
|
|
2008
|
+
* // ```sh
|
|
2009
|
+
* // $ npm install googleapis
|
|
2010
|
+
* // ```
|
|
2011
|
+
*
|
|
2012
|
+
* const {google} = require('googleapis');
|
|
2013
|
+
* const dataform = google.dataform('v1beta1');
|
|
2014
|
+
*
|
|
2015
|
+
* async function main() {
|
|
2016
|
+
* const auth = new google.auth.GoogleAuth({
|
|
2017
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
2018
|
+
* scopes: [
|
|
2019
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
2020
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
2021
|
+
* ],
|
|
2022
|
+
* });
|
|
2023
|
+
*
|
|
2024
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
2025
|
+
* const authClient = await auth.getClient();
|
|
2026
|
+
* google.options({auth: authClient});
|
|
2027
|
+
*
|
|
2028
|
+
* // Do the magic
|
|
2029
|
+
* const res = await dataform.projects.locations.list({
|
|
2030
|
+
* // Optional. A list of extra location types that should be used as conditions for controlling the visibility of the locations.
|
|
2031
|
+
* extraLocationTypes: 'placeholder-value',
|
|
2032
|
+
* // A filter to narrow down results to a preferred subset. The filtering language accepts strings like `"displayName=tokyo"`, and is documented in more detail in [AIP-160](https://google.aip.dev/160).
|
|
2033
|
+
* filter: 'placeholder-value',
|
|
2034
|
+
* // The resource that owns the locations collection, if applicable.
|
|
2035
|
+
* name: 'projects/my-project',
|
|
2036
|
+
* // The maximum number of results to return. If not set, the service selects a default.
|
|
2037
|
+
* pageSize: 'placeholder-value',
|
|
2038
|
+
* // A page token received from the `next_page_token` field in the response. Send that page token to receive the subsequent page.
|
|
2039
|
+
* pageToken: 'placeholder-value',
|
|
2040
|
+
* });
|
|
2041
|
+
* console.log(res.data);
|
|
2042
|
+
*
|
|
2043
|
+
* // Example response
|
|
2044
|
+
* // {
|
|
2045
|
+
* // "locations": [],
|
|
2046
|
+
* // "nextPageToken": "my_nextPageToken"
|
|
2047
|
+
* // }
|
|
2048
|
+
* }
|
|
2049
|
+
*
|
|
2050
|
+
* main().catch(e => {
|
|
2051
|
+
* console.error(e);
|
|
2052
|
+
* throw e;
|
|
2053
|
+
* });
|
|
2054
|
+
*
|
|
2055
|
+
* ```
|
|
1891
2056
|
*
|
|
1892
2057
|
* @param params - Parameters for request
|
|
1893
2058
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
1894
2059
|
* @param callback - Optional callback that handles the response.
|
|
1895
2060
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
1896
2061
|
*/
|
|
1897
|
-
list(params: Params$Resource$Projects$Locations$List, options: StreamMethodOptions):
|
|
1898
|
-
list(params?: Params$Resource$Projects$Locations$List, options?: MethodOptions):
|
|
2062
|
+
list(params: Params$Resource$Projects$Locations$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
2063
|
+
list(params?: Params$Resource$Projects$Locations$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListLocationsResponse>>;
|
|
1899
2064
|
list(params: Params$Resource$Projects$Locations$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
1900
2065
|
list(params: Params$Resource$Projects$Locations$List, options: MethodOptions | BodyResponseCallback<Schema$ListLocationsResponse>, callback: BodyResponseCallback<Schema$ListLocationsResponse>): void;
|
|
1901
2066
|
list(params: Params$Resource$Projects$Locations$List, callback: BodyResponseCallback<Schema$ListLocationsResponse>): void;
|
|
1902
2067
|
list(callback: BodyResponseCallback<Schema$ListLocationsResponse>): void;
|
|
1903
2068
|
/**
|
|
1904
2069
|
* Update default config for a given project and location. **Note:** *This method does not fully implement [AIP/134](https://google.aip.dev/134). The wildcard entry (\*) is treated as a bad request, and when the `field_mask` is omitted, the request is treated as a full update on all modifiable fields.*
|
|
2070
|
+
* @example
|
|
2071
|
+
* ```js
|
|
2072
|
+
* // Before running the sample:
|
|
2073
|
+
* // - Enable the API at:
|
|
2074
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
2075
|
+
* // - Login into gcloud by running:
|
|
2076
|
+
* // ```sh
|
|
2077
|
+
* // $ gcloud auth application-default login
|
|
2078
|
+
* // ```
|
|
2079
|
+
* // - Install the npm module by running:
|
|
2080
|
+
* // ```sh
|
|
2081
|
+
* // $ npm install googleapis
|
|
2082
|
+
* // ```
|
|
2083
|
+
*
|
|
2084
|
+
* const {google} = require('googleapis');
|
|
2085
|
+
* const dataform = google.dataform('v1beta1');
|
|
2086
|
+
*
|
|
2087
|
+
* async function main() {
|
|
2088
|
+
* const auth = new google.auth.GoogleAuth({
|
|
2089
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
2090
|
+
* scopes: [
|
|
2091
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
2092
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
2093
|
+
* ],
|
|
2094
|
+
* });
|
|
2095
|
+
*
|
|
2096
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
2097
|
+
* const authClient = await auth.getClient();
|
|
2098
|
+
* google.options({auth: authClient});
|
|
2099
|
+
*
|
|
2100
|
+
* // Do the magic
|
|
2101
|
+
* const res = await dataform.projects.locations.updateConfig({
|
|
2102
|
+
* // Identifier. The config name.
|
|
2103
|
+
* name: 'projects/my-project/locations/my-location/config',
|
|
2104
|
+
* // Optional. Specifies the fields to be updated in the config.
|
|
2105
|
+
* updateMask: 'placeholder-value',
|
|
2106
|
+
*
|
|
2107
|
+
* // Request body metadata
|
|
2108
|
+
* requestBody: {
|
|
2109
|
+
* // request body parameters
|
|
2110
|
+
* // {
|
|
2111
|
+
* // "defaultKmsKeyName": "my_defaultKmsKeyName",
|
|
2112
|
+
* // "name": "my_name"
|
|
2113
|
+
* // }
|
|
2114
|
+
* },
|
|
2115
|
+
* });
|
|
2116
|
+
* console.log(res.data);
|
|
2117
|
+
*
|
|
2118
|
+
* // Example response
|
|
2119
|
+
* // {
|
|
2120
|
+
* // "defaultKmsKeyName": "my_defaultKmsKeyName",
|
|
2121
|
+
* // "name": "my_name"
|
|
2122
|
+
* // }
|
|
2123
|
+
* }
|
|
2124
|
+
*
|
|
2125
|
+
* main().catch(e => {
|
|
2126
|
+
* console.error(e);
|
|
2127
|
+
* throw e;
|
|
2128
|
+
* });
|
|
2129
|
+
*
|
|
2130
|
+
* ```
|
|
1905
2131
|
*
|
|
1906
2132
|
* @param params - Parameters for request
|
|
1907
2133
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
1908
2134
|
* @param callback - Optional callback that handles the response.
|
|
1909
2135
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
1910
2136
|
*/
|
|
1911
|
-
updateConfig(params: Params$Resource$Projects$Locations$Updateconfig, options: StreamMethodOptions):
|
|
1912
|
-
updateConfig(params?: Params$Resource$Projects$Locations$Updateconfig, options?: MethodOptions):
|
|
2137
|
+
updateConfig(params: Params$Resource$Projects$Locations$Updateconfig, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
2138
|
+
updateConfig(params?: Params$Resource$Projects$Locations$Updateconfig, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Config>>;
|
|
1913
2139
|
updateConfig(params: Params$Resource$Projects$Locations$Updateconfig, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
1914
2140
|
updateConfig(params: Params$Resource$Projects$Locations$Updateconfig, options: MethodOptions | BodyResponseCallback<Schema$Config>, callback: BodyResponseCallback<Schema$Config>): void;
|
|
1915
2141
|
updateConfig(params: Params$Resource$Projects$Locations$Updateconfig, callback: BodyResponseCallback<Schema$Config>): void;
|
|
@@ -1973,196 +2199,1025 @@ export declare namespace dataform_v1beta1 {
|
|
|
1973
2199
|
constructor(context: APIRequestContext);
|
|
1974
2200
|
/**
|
|
1975
2201
|
* Applies a Git commit to a Repository. The Repository must not have a value for `git_remote_settings.url`.
|
|
2202
|
+
* @example
|
|
2203
|
+
* ```js
|
|
2204
|
+
* // Before running the sample:
|
|
2205
|
+
* // - Enable the API at:
|
|
2206
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
2207
|
+
* // - Login into gcloud by running:
|
|
2208
|
+
* // ```sh
|
|
2209
|
+
* // $ gcloud auth application-default login
|
|
2210
|
+
* // ```
|
|
2211
|
+
* // - Install the npm module by running:
|
|
2212
|
+
* // ```sh
|
|
2213
|
+
* // $ npm install googleapis
|
|
2214
|
+
* // ```
|
|
2215
|
+
*
|
|
2216
|
+
* const {google} = require('googleapis');
|
|
2217
|
+
* const dataform = google.dataform('v1beta1');
|
|
2218
|
+
*
|
|
2219
|
+
* async function main() {
|
|
2220
|
+
* const auth = new google.auth.GoogleAuth({
|
|
2221
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
2222
|
+
* scopes: [
|
|
2223
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
2224
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
2225
|
+
* ],
|
|
2226
|
+
* });
|
|
2227
|
+
*
|
|
2228
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
2229
|
+
* const authClient = await auth.getClient();
|
|
2230
|
+
* google.options({auth: authClient});
|
|
2231
|
+
*
|
|
2232
|
+
* // Do the magic
|
|
2233
|
+
* const res = await dataform.projects.locations.repositories.commit({
|
|
2234
|
+
* // Required. The repository's name.
|
|
2235
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie',
|
|
2236
|
+
*
|
|
2237
|
+
* // Request body metadata
|
|
2238
|
+
* requestBody: {
|
|
2239
|
+
* // request body parameters
|
|
2240
|
+
* // {
|
|
2241
|
+
* // "commitMetadata": {},
|
|
2242
|
+
* // "fileOperations": {},
|
|
2243
|
+
* // "requiredHeadCommitSha": "my_requiredHeadCommitSha"
|
|
2244
|
+
* // }
|
|
2245
|
+
* },
|
|
2246
|
+
* });
|
|
2247
|
+
* console.log(res.data);
|
|
2248
|
+
*
|
|
2249
|
+
* // Example response
|
|
2250
|
+
* // {
|
|
2251
|
+
* // "commitSha": "my_commitSha"
|
|
2252
|
+
* // }
|
|
2253
|
+
* }
|
|
2254
|
+
*
|
|
2255
|
+
* main().catch(e => {
|
|
2256
|
+
* console.error(e);
|
|
2257
|
+
* throw e;
|
|
2258
|
+
* });
|
|
2259
|
+
*
|
|
2260
|
+
* ```
|
|
1976
2261
|
*
|
|
1977
2262
|
* @param params - Parameters for request
|
|
1978
2263
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
1979
2264
|
* @param callback - Optional callback that handles the response.
|
|
1980
2265
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
1981
2266
|
*/
|
|
1982
|
-
commit(params: Params$Resource$Projects$Locations$Repositories$Commit, options: StreamMethodOptions):
|
|
1983
|
-
commit(params?: Params$Resource$Projects$Locations$Repositories$Commit, options?: MethodOptions):
|
|
2267
|
+
commit(params: Params$Resource$Projects$Locations$Repositories$Commit, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
2268
|
+
commit(params?: Params$Resource$Projects$Locations$Repositories$Commit, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$CommitRepositoryChangesResponse>>;
|
|
1984
2269
|
commit(params: Params$Resource$Projects$Locations$Repositories$Commit, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
1985
2270
|
commit(params: Params$Resource$Projects$Locations$Repositories$Commit, options: MethodOptions | BodyResponseCallback<Schema$CommitRepositoryChangesResponse>, callback: BodyResponseCallback<Schema$CommitRepositoryChangesResponse>): void;
|
|
1986
2271
|
commit(params: Params$Resource$Projects$Locations$Repositories$Commit, callback: BodyResponseCallback<Schema$CommitRepositoryChangesResponse>): void;
|
|
1987
2272
|
commit(callback: BodyResponseCallback<Schema$CommitRepositoryChangesResponse>): void;
|
|
1988
2273
|
/**
|
|
1989
2274
|
* Computes a Repository's Git access token status.
|
|
2275
|
+
* @example
|
|
2276
|
+
* ```js
|
|
2277
|
+
* // Before running the sample:
|
|
2278
|
+
* // - Enable the API at:
|
|
2279
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
2280
|
+
* // - Login into gcloud by running:
|
|
2281
|
+
* // ```sh
|
|
2282
|
+
* // $ gcloud auth application-default login
|
|
2283
|
+
* // ```
|
|
2284
|
+
* // - Install the npm module by running:
|
|
2285
|
+
* // ```sh
|
|
2286
|
+
* // $ npm install googleapis
|
|
2287
|
+
* // ```
|
|
2288
|
+
*
|
|
2289
|
+
* const {google} = require('googleapis');
|
|
2290
|
+
* const dataform = google.dataform('v1beta1');
|
|
2291
|
+
*
|
|
2292
|
+
* async function main() {
|
|
2293
|
+
* const auth = new google.auth.GoogleAuth({
|
|
2294
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
2295
|
+
* scopes: [
|
|
2296
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
2297
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
2298
|
+
* ],
|
|
2299
|
+
* });
|
|
2300
|
+
*
|
|
2301
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
2302
|
+
* const authClient = await auth.getClient();
|
|
2303
|
+
* google.options({auth: authClient});
|
|
2304
|
+
*
|
|
2305
|
+
* // Do the magic
|
|
2306
|
+
* const res =
|
|
2307
|
+
* await dataform.projects.locations.repositories.computeAccessTokenStatus({
|
|
2308
|
+
* // Required. The repository's name.
|
|
2309
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie',
|
|
2310
|
+
* });
|
|
2311
|
+
* console.log(res.data);
|
|
2312
|
+
*
|
|
2313
|
+
* // Example response
|
|
2314
|
+
* // {
|
|
2315
|
+
* // "tokenStatus": "my_tokenStatus"
|
|
2316
|
+
* // }
|
|
2317
|
+
* }
|
|
2318
|
+
*
|
|
2319
|
+
* main().catch(e => {
|
|
2320
|
+
* console.error(e);
|
|
2321
|
+
* throw e;
|
|
2322
|
+
* });
|
|
2323
|
+
*
|
|
2324
|
+
* ```
|
|
1990
2325
|
*
|
|
1991
2326
|
* @param params - Parameters for request
|
|
1992
2327
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
1993
2328
|
* @param callback - Optional callback that handles the response.
|
|
1994
2329
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
1995
2330
|
*/
|
|
1996
|
-
computeAccessTokenStatus(params: Params$Resource$Projects$Locations$Repositories$Computeaccesstokenstatus, options: StreamMethodOptions):
|
|
1997
|
-
computeAccessTokenStatus(params?: Params$Resource$Projects$Locations$Repositories$Computeaccesstokenstatus, options?: MethodOptions):
|
|
2331
|
+
computeAccessTokenStatus(params: Params$Resource$Projects$Locations$Repositories$Computeaccesstokenstatus, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
2332
|
+
computeAccessTokenStatus(params?: Params$Resource$Projects$Locations$Repositories$Computeaccesstokenstatus, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ComputeRepositoryAccessTokenStatusResponse>>;
|
|
1998
2333
|
computeAccessTokenStatus(params: Params$Resource$Projects$Locations$Repositories$Computeaccesstokenstatus, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
1999
2334
|
computeAccessTokenStatus(params: Params$Resource$Projects$Locations$Repositories$Computeaccesstokenstatus, options: MethodOptions | BodyResponseCallback<Schema$ComputeRepositoryAccessTokenStatusResponse>, callback: BodyResponseCallback<Schema$ComputeRepositoryAccessTokenStatusResponse>): void;
|
|
2000
2335
|
computeAccessTokenStatus(params: Params$Resource$Projects$Locations$Repositories$Computeaccesstokenstatus, callback: BodyResponseCallback<Schema$ComputeRepositoryAccessTokenStatusResponse>): void;
|
|
2001
2336
|
computeAccessTokenStatus(callback: BodyResponseCallback<Schema$ComputeRepositoryAccessTokenStatusResponse>): void;
|
|
2002
2337
|
/**
|
|
2003
2338
|
* Creates a new Repository in a given project and location.
|
|
2339
|
+
* @example
|
|
2340
|
+
* ```js
|
|
2341
|
+
* // Before running the sample:
|
|
2342
|
+
* // - Enable the API at:
|
|
2343
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
2344
|
+
* // - Login into gcloud by running:
|
|
2345
|
+
* // ```sh
|
|
2346
|
+
* // $ gcloud auth application-default login
|
|
2347
|
+
* // ```
|
|
2348
|
+
* // - Install the npm module by running:
|
|
2349
|
+
* // ```sh
|
|
2350
|
+
* // $ npm install googleapis
|
|
2351
|
+
* // ```
|
|
2352
|
+
*
|
|
2353
|
+
* const {google} = require('googleapis');
|
|
2354
|
+
* const dataform = google.dataform('v1beta1');
|
|
2355
|
+
*
|
|
2356
|
+
* async function main() {
|
|
2357
|
+
* const auth = new google.auth.GoogleAuth({
|
|
2358
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
2359
|
+
* scopes: [
|
|
2360
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
2361
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
2362
|
+
* ],
|
|
2363
|
+
* });
|
|
2364
|
+
*
|
|
2365
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
2366
|
+
* const authClient = await auth.getClient();
|
|
2367
|
+
* google.options({auth: authClient});
|
|
2368
|
+
*
|
|
2369
|
+
* // Do the magic
|
|
2370
|
+
* const res = await dataform.projects.locations.repositories.create({
|
|
2371
|
+
* // Required. The location in which to create the repository. Must be in the format `projects/x/locations/x`.
|
|
2372
|
+
* parent: 'projects/my-project/locations/my-location',
|
|
2373
|
+
* // Required. The ID to use for the repository, which will become the final component of the repository's resource name.
|
|
2374
|
+
* repositoryId: 'placeholder-value',
|
|
2375
|
+
*
|
|
2376
|
+
* // Request body metadata
|
|
2377
|
+
* requestBody: {
|
|
2378
|
+
* // request body parameters
|
|
2379
|
+
* // {
|
|
2380
|
+
* // "createTime": "my_createTime",
|
|
2381
|
+
* // "dataEncryptionState": {},
|
|
2382
|
+
* // "displayName": "my_displayName",
|
|
2383
|
+
* // "gitRemoteSettings": {},
|
|
2384
|
+
* // "internalMetadata": "my_internalMetadata",
|
|
2385
|
+
* // "kmsKeyName": "my_kmsKeyName",
|
|
2386
|
+
* // "labels": {},
|
|
2387
|
+
* // "name": "my_name",
|
|
2388
|
+
* // "npmrcEnvironmentVariablesSecretVersion": "my_npmrcEnvironmentVariablesSecretVersion",
|
|
2389
|
+
* // "serviceAccount": "my_serviceAccount",
|
|
2390
|
+
* // "setAuthenticatedUserAdmin": false,
|
|
2391
|
+
* // "workspaceCompilationOverrides": {}
|
|
2392
|
+
* // }
|
|
2393
|
+
* },
|
|
2394
|
+
* });
|
|
2395
|
+
* console.log(res.data);
|
|
2396
|
+
*
|
|
2397
|
+
* // Example response
|
|
2398
|
+
* // {
|
|
2399
|
+
* // "createTime": "my_createTime",
|
|
2400
|
+
* // "dataEncryptionState": {},
|
|
2401
|
+
* // "displayName": "my_displayName",
|
|
2402
|
+
* // "gitRemoteSettings": {},
|
|
2403
|
+
* // "internalMetadata": "my_internalMetadata",
|
|
2404
|
+
* // "kmsKeyName": "my_kmsKeyName",
|
|
2405
|
+
* // "labels": {},
|
|
2406
|
+
* // "name": "my_name",
|
|
2407
|
+
* // "npmrcEnvironmentVariablesSecretVersion": "my_npmrcEnvironmentVariablesSecretVersion",
|
|
2408
|
+
* // "serviceAccount": "my_serviceAccount",
|
|
2409
|
+
* // "setAuthenticatedUserAdmin": false,
|
|
2410
|
+
* // "workspaceCompilationOverrides": {}
|
|
2411
|
+
* // }
|
|
2412
|
+
* }
|
|
2413
|
+
*
|
|
2414
|
+
* main().catch(e => {
|
|
2415
|
+
* console.error(e);
|
|
2416
|
+
* throw e;
|
|
2417
|
+
* });
|
|
2418
|
+
*
|
|
2419
|
+
* ```
|
|
2004
2420
|
*
|
|
2005
2421
|
* @param params - Parameters for request
|
|
2006
2422
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2007
2423
|
* @param callback - Optional callback that handles the response.
|
|
2008
2424
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2009
2425
|
*/
|
|
2010
|
-
create(params: Params$Resource$Projects$Locations$Repositories$Create, options: StreamMethodOptions):
|
|
2011
|
-
create(params?: Params$Resource$Projects$Locations$Repositories$Create, options?: MethodOptions):
|
|
2426
|
+
create(params: Params$Resource$Projects$Locations$Repositories$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
2427
|
+
create(params?: Params$Resource$Projects$Locations$Repositories$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Repository>>;
|
|
2012
2428
|
create(params: Params$Resource$Projects$Locations$Repositories$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2013
2429
|
create(params: Params$Resource$Projects$Locations$Repositories$Create, options: MethodOptions | BodyResponseCallback<Schema$Repository>, callback: BodyResponseCallback<Schema$Repository>): void;
|
|
2014
2430
|
create(params: Params$Resource$Projects$Locations$Repositories$Create, callback: BodyResponseCallback<Schema$Repository>): void;
|
|
2015
2431
|
create(callback: BodyResponseCallback<Schema$Repository>): void;
|
|
2016
2432
|
/**
|
|
2017
2433
|
* Deletes a single Repository.
|
|
2434
|
+
* @example
|
|
2435
|
+
* ```js
|
|
2436
|
+
* // Before running the sample:
|
|
2437
|
+
* // - Enable the API at:
|
|
2438
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
2439
|
+
* // - Login into gcloud by running:
|
|
2440
|
+
* // ```sh
|
|
2441
|
+
* // $ gcloud auth application-default login
|
|
2442
|
+
* // ```
|
|
2443
|
+
* // - Install the npm module by running:
|
|
2444
|
+
* // ```sh
|
|
2445
|
+
* // $ npm install googleapis
|
|
2446
|
+
* // ```
|
|
2447
|
+
*
|
|
2448
|
+
* const {google} = require('googleapis');
|
|
2449
|
+
* const dataform = google.dataform('v1beta1');
|
|
2450
|
+
*
|
|
2451
|
+
* async function main() {
|
|
2452
|
+
* const auth = new google.auth.GoogleAuth({
|
|
2453
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
2454
|
+
* scopes: [
|
|
2455
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
2456
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
2457
|
+
* ],
|
|
2458
|
+
* });
|
|
2459
|
+
*
|
|
2460
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
2461
|
+
* const authClient = await auth.getClient();
|
|
2462
|
+
* google.options({auth: authClient});
|
|
2463
|
+
*
|
|
2464
|
+
* // Do the magic
|
|
2465
|
+
* const res = await dataform.projects.locations.repositories.delete({
|
|
2466
|
+
* // Optional. If set to true, child resources of this repository (compilation results and workflow invocations) will also be deleted. Otherwise, the request will only succeed if the repository has no child resources. **Note:** *This flag doesn't support deletion of workspaces, release configs or workflow configs. If any of such resources exists in the repository, the request will fail.*.
|
|
2467
|
+
* force: 'placeholder-value',
|
|
2468
|
+
* // Required. The repository's name.
|
|
2469
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie',
|
|
2470
|
+
* });
|
|
2471
|
+
* console.log(res.data);
|
|
2472
|
+
*
|
|
2473
|
+
* // Example response
|
|
2474
|
+
* // {}
|
|
2475
|
+
* }
|
|
2476
|
+
*
|
|
2477
|
+
* main().catch(e => {
|
|
2478
|
+
* console.error(e);
|
|
2479
|
+
* throw e;
|
|
2480
|
+
* });
|
|
2481
|
+
*
|
|
2482
|
+
* ```
|
|
2018
2483
|
*
|
|
2019
2484
|
* @param params - Parameters for request
|
|
2020
2485
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2021
2486
|
* @param callback - Optional callback that handles the response.
|
|
2022
2487
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2023
2488
|
*/
|
|
2024
|
-
delete(params: Params$Resource$Projects$Locations$Repositories$Delete, options: StreamMethodOptions):
|
|
2025
|
-
delete(params?: Params$Resource$Projects$Locations$Repositories$Delete, options?: MethodOptions):
|
|
2489
|
+
delete(params: Params$Resource$Projects$Locations$Repositories$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
2490
|
+
delete(params?: Params$Resource$Projects$Locations$Repositories$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Empty>>;
|
|
2026
2491
|
delete(params: Params$Resource$Projects$Locations$Repositories$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2027
2492
|
delete(params: Params$Resource$Projects$Locations$Repositories$Delete, options: MethodOptions | BodyResponseCallback<Schema$Empty>, callback: BodyResponseCallback<Schema$Empty>): void;
|
|
2028
2493
|
delete(params: Params$Resource$Projects$Locations$Repositories$Delete, callback: BodyResponseCallback<Schema$Empty>): void;
|
|
2029
2494
|
delete(callback: BodyResponseCallback<Schema$Empty>): void;
|
|
2030
2495
|
/**
|
|
2031
2496
|
* Fetches a Repository's history of commits. The Repository must not have a value for `git_remote_settings.url`.
|
|
2497
|
+
* @example
|
|
2498
|
+
* ```js
|
|
2499
|
+
* // Before running the sample:
|
|
2500
|
+
* // - Enable the API at:
|
|
2501
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
2502
|
+
* // - Login into gcloud by running:
|
|
2503
|
+
* // ```sh
|
|
2504
|
+
* // $ gcloud auth application-default login
|
|
2505
|
+
* // ```
|
|
2506
|
+
* // - Install the npm module by running:
|
|
2507
|
+
* // ```sh
|
|
2508
|
+
* // $ npm install googleapis
|
|
2509
|
+
* // ```
|
|
2510
|
+
*
|
|
2511
|
+
* const {google} = require('googleapis');
|
|
2512
|
+
* const dataform = google.dataform('v1beta1');
|
|
2513
|
+
*
|
|
2514
|
+
* async function main() {
|
|
2515
|
+
* const auth = new google.auth.GoogleAuth({
|
|
2516
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
2517
|
+
* scopes: [
|
|
2518
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
2519
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
2520
|
+
* ],
|
|
2521
|
+
* });
|
|
2522
|
+
*
|
|
2523
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
2524
|
+
* const authClient = await auth.getClient();
|
|
2525
|
+
* google.options({auth: authClient});
|
|
2526
|
+
*
|
|
2527
|
+
* // Do the magic
|
|
2528
|
+
* const res = await dataform.projects.locations.repositories.fetchHistory({
|
|
2529
|
+
* // Required. The repository's name.
|
|
2530
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie',
|
|
2531
|
+
* // Optional. Maximum number of commits to return. The server may return fewer items than requested. If unspecified, the server will pick an appropriate default.
|
|
2532
|
+
* pageSize: 'placeholder-value',
|
|
2533
|
+
* // Optional. Page token received from a previous `FetchRepositoryHistory` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `FetchRepositoryHistory`, with the exception of `page_size`, must match the call that provided the page token.
|
|
2534
|
+
* pageToken: 'placeholder-value',
|
|
2535
|
+
* });
|
|
2536
|
+
* console.log(res.data);
|
|
2537
|
+
*
|
|
2538
|
+
* // Example response
|
|
2539
|
+
* // {
|
|
2540
|
+
* // "commits": [],
|
|
2541
|
+
* // "nextPageToken": "my_nextPageToken"
|
|
2542
|
+
* // }
|
|
2543
|
+
* }
|
|
2544
|
+
*
|
|
2545
|
+
* main().catch(e => {
|
|
2546
|
+
* console.error(e);
|
|
2547
|
+
* throw e;
|
|
2548
|
+
* });
|
|
2549
|
+
*
|
|
2550
|
+
* ```
|
|
2032
2551
|
*
|
|
2033
2552
|
* @param params - Parameters for request
|
|
2034
2553
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2035
2554
|
* @param callback - Optional callback that handles the response.
|
|
2036
2555
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2037
2556
|
*/
|
|
2038
|
-
fetchHistory(params: Params$Resource$Projects$Locations$Repositories$Fetchhistory, options: StreamMethodOptions):
|
|
2039
|
-
fetchHistory(params?: Params$Resource$Projects$Locations$Repositories$Fetchhistory, options?: MethodOptions):
|
|
2557
|
+
fetchHistory(params: Params$Resource$Projects$Locations$Repositories$Fetchhistory, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
2558
|
+
fetchHistory(params?: Params$Resource$Projects$Locations$Repositories$Fetchhistory, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$FetchRepositoryHistoryResponse>>;
|
|
2040
2559
|
fetchHistory(params: Params$Resource$Projects$Locations$Repositories$Fetchhistory, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2041
2560
|
fetchHistory(params: Params$Resource$Projects$Locations$Repositories$Fetchhistory, options: MethodOptions | BodyResponseCallback<Schema$FetchRepositoryHistoryResponse>, callback: BodyResponseCallback<Schema$FetchRepositoryHistoryResponse>): void;
|
|
2042
2561
|
fetchHistory(params: Params$Resource$Projects$Locations$Repositories$Fetchhistory, callback: BodyResponseCallback<Schema$FetchRepositoryHistoryResponse>): void;
|
|
2043
2562
|
fetchHistory(callback: BodyResponseCallback<Schema$FetchRepositoryHistoryResponse>): void;
|
|
2044
2563
|
/**
|
|
2045
2564
|
* Fetches a Repository's remote branches.
|
|
2565
|
+
* @example
|
|
2566
|
+
* ```js
|
|
2567
|
+
* // Before running the sample:
|
|
2568
|
+
* // - Enable the API at:
|
|
2569
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
2570
|
+
* // - Login into gcloud by running:
|
|
2571
|
+
* // ```sh
|
|
2572
|
+
* // $ gcloud auth application-default login
|
|
2573
|
+
* // ```
|
|
2574
|
+
* // - Install the npm module by running:
|
|
2575
|
+
* // ```sh
|
|
2576
|
+
* // $ npm install googleapis
|
|
2577
|
+
* // ```
|
|
2578
|
+
*
|
|
2579
|
+
* const {google} = require('googleapis');
|
|
2580
|
+
* const dataform = google.dataform('v1beta1');
|
|
2581
|
+
*
|
|
2582
|
+
* async function main() {
|
|
2583
|
+
* const auth = new google.auth.GoogleAuth({
|
|
2584
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
2585
|
+
* scopes: [
|
|
2586
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
2587
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
2588
|
+
* ],
|
|
2589
|
+
* });
|
|
2590
|
+
*
|
|
2591
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
2592
|
+
* const authClient = await auth.getClient();
|
|
2593
|
+
* google.options({auth: authClient});
|
|
2594
|
+
*
|
|
2595
|
+
* // Do the magic
|
|
2596
|
+
* const res =
|
|
2597
|
+
* await dataform.projects.locations.repositories.fetchRemoteBranches({
|
|
2598
|
+
* // Required. The repository's name.
|
|
2599
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie',
|
|
2600
|
+
* });
|
|
2601
|
+
* console.log(res.data);
|
|
2602
|
+
*
|
|
2603
|
+
* // Example response
|
|
2604
|
+
* // {
|
|
2605
|
+
* // "branches": []
|
|
2606
|
+
* // }
|
|
2607
|
+
* }
|
|
2608
|
+
*
|
|
2609
|
+
* main().catch(e => {
|
|
2610
|
+
* console.error(e);
|
|
2611
|
+
* throw e;
|
|
2612
|
+
* });
|
|
2613
|
+
*
|
|
2614
|
+
* ```
|
|
2046
2615
|
*
|
|
2047
2616
|
* @param params - Parameters for request
|
|
2048
2617
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2049
2618
|
* @param callback - Optional callback that handles the response.
|
|
2050
2619
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2051
2620
|
*/
|
|
2052
|
-
fetchRemoteBranches(params: Params$Resource$Projects$Locations$Repositories$Fetchremotebranches, options: StreamMethodOptions):
|
|
2053
|
-
fetchRemoteBranches(params?: Params$Resource$Projects$Locations$Repositories$Fetchremotebranches, options?: MethodOptions):
|
|
2621
|
+
fetchRemoteBranches(params: Params$Resource$Projects$Locations$Repositories$Fetchremotebranches, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
2622
|
+
fetchRemoteBranches(params?: Params$Resource$Projects$Locations$Repositories$Fetchremotebranches, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$FetchRemoteBranchesResponse>>;
|
|
2054
2623
|
fetchRemoteBranches(params: Params$Resource$Projects$Locations$Repositories$Fetchremotebranches, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2055
2624
|
fetchRemoteBranches(params: Params$Resource$Projects$Locations$Repositories$Fetchremotebranches, options: MethodOptions | BodyResponseCallback<Schema$FetchRemoteBranchesResponse>, callback: BodyResponseCallback<Schema$FetchRemoteBranchesResponse>): void;
|
|
2056
2625
|
fetchRemoteBranches(params: Params$Resource$Projects$Locations$Repositories$Fetchremotebranches, callback: BodyResponseCallback<Schema$FetchRemoteBranchesResponse>): void;
|
|
2057
2626
|
fetchRemoteBranches(callback: BodyResponseCallback<Schema$FetchRemoteBranchesResponse>): void;
|
|
2058
2627
|
/**
|
|
2059
2628
|
* Fetches a single Repository.
|
|
2629
|
+
* @example
|
|
2630
|
+
* ```js
|
|
2631
|
+
* // Before running the sample:
|
|
2632
|
+
* // - Enable the API at:
|
|
2633
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
2634
|
+
* // - Login into gcloud by running:
|
|
2635
|
+
* // ```sh
|
|
2636
|
+
* // $ gcloud auth application-default login
|
|
2637
|
+
* // ```
|
|
2638
|
+
* // - Install the npm module by running:
|
|
2639
|
+
* // ```sh
|
|
2640
|
+
* // $ npm install googleapis
|
|
2641
|
+
* // ```
|
|
2642
|
+
*
|
|
2643
|
+
* const {google} = require('googleapis');
|
|
2644
|
+
* const dataform = google.dataform('v1beta1');
|
|
2645
|
+
*
|
|
2646
|
+
* async function main() {
|
|
2647
|
+
* const auth = new google.auth.GoogleAuth({
|
|
2648
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
2649
|
+
* scopes: [
|
|
2650
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
2651
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
2652
|
+
* ],
|
|
2653
|
+
* });
|
|
2654
|
+
*
|
|
2655
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
2656
|
+
* const authClient = await auth.getClient();
|
|
2657
|
+
* google.options({auth: authClient});
|
|
2658
|
+
*
|
|
2659
|
+
* // Do the magic
|
|
2660
|
+
* const res = await dataform.projects.locations.repositories.get({
|
|
2661
|
+
* // Required. The repository's name.
|
|
2662
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie',
|
|
2663
|
+
* });
|
|
2664
|
+
* console.log(res.data);
|
|
2665
|
+
*
|
|
2666
|
+
* // Example response
|
|
2667
|
+
* // {
|
|
2668
|
+
* // "createTime": "my_createTime",
|
|
2669
|
+
* // "dataEncryptionState": {},
|
|
2670
|
+
* // "displayName": "my_displayName",
|
|
2671
|
+
* // "gitRemoteSettings": {},
|
|
2672
|
+
* // "internalMetadata": "my_internalMetadata",
|
|
2673
|
+
* // "kmsKeyName": "my_kmsKeyName",
|
|
2674
|
+
* // "labels": {},
|
|
2675
|
+
* // "name": "my_name",
|
|
2676
|
+
* // "npmrcEnvironmentVariablesSecretVersion": "my_npmrcEnvironmentVariablesSecretVersion",
|
|
2677
|
+
* // "serviceAccount": "my_serviceAccount",
|
|
2678
|
+
* // "setAuthenticatedUserAdmin": false,
|
|
2679
|
+
* // "workspaceCompilationOverrides": {}
|
|
2680
|
+
* // }
|
|
2681
|
+
* }
|
|
2682
|
+
*
|
|
2683
|
+
* main().catch(e => {
|
|
2684
|
+
* console.error(e);
|
|
2685
|
+
* throw e;
|
|
2686
|
+
* });
|
|
2687
|
+
*
|
|
2688
|
+
* ```
|
|
2060
2689
|
*
|
|
2061
2690
|
* @param params - Parameters for request
|
|
2062
2691
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2063
2692
|
* @param callback - Optional callback that handles the response.
|
|
2064
2693
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2065
2694
|
*/
|
|
2066
|
-
get(params: Params$Resource$Projects$Locations$Repositories$Get, options: StreamMethodOptions):
|
|
2067
|
-
get(params?: Params$Resource$Projects$Locations$Repositories$Get, options?: MethodOptions):
|
|
2695
|
+
get(params: Params$Resource$Projects$Locations$Repositories$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
2696
|
+
get(params?: Params$Resource$Projects$Locations$Repositories$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Repository>>;
|
|
2068
2697
|
get(params: Params$Resource$Projects$Locations$Repositories$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2069
2698
|
get(params: Params$Resource$Projects$Locations$Repositories$Get, options: MethodOptions | BodyResponseCallback<Schema$Repository>, callback: BodyResponseCallback<Schema$Repository>): void;
|
|
2070
2699
|
get(params: Params$Resource$Projects$Locations$Repositories$Get, callback: BodyResponseCallback<Schema$Repository>): void;
|
|
2071
2700
|
get(callback: BodyResponseCallback<Schema$Repository>): void;
|
|
2072
2701
|
/**
|
|
2073
2702
|
* Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.
|
|
2703
|
+
* @example
|
|
2704
|
+
* ```js
|
|
2705
|
+
* // Before running the sample:
|
|
2706
|
+
* // - Enable the API at:
|
|
2707
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
2708
|
+
* // - Login into gcloud by running:
|
|
2709
|
+
* // ```sh
|
|
2710
|
+
* // $ gcloud auth application-default login
|
|
2711
|
+
* // ```
|
|
2712
|
+
* // - Install the npm module by running:
|
|
2713
|
+
* // ```sh
|
|
2714
|
+
* // $ npm install googleapis
|
|
2715
|
+
* // ```
|
|
2716
|
+
*
|
|
2717
|
+
* const {google} = require('googleapis');
|
|
2718
|
+
* const dataform = google.dataform('v1beta1');
|
|
2719
|
+
*
|
|
2720
|
+
* async function main() {
|
|
2721
|
+
* const auth = new google.auth.GoogleAuth({
|
|
2722
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
2723
|
+
* scopes: [
|
|
2724
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
2725
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
2726
|
+
* ],
|
|
2727
|
+
* });
|
|
2728
|
+
*
|
|
2729
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
2730
|
+
* const authClient = await auth.getClient();
|
|
2731
|
+
* google.options({auth: authClient});
|
|
2732
|
+
*
|
|
2733
|
+
* // Do the magic
|
|
2734
|
+
* const res = await dataform.projects.locations.repositories.getIamPolicy({
|
|
2735
|
+
* // Optional. The maximum policy version that will be used to format the policy. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional role bindings must specify version 3. Policies with no conditional role bindings may specify any valid value or leave the field unset. The policy in the response might use the policy version that you specified, or it might use a lower policy version. For example, if you specify version 3, but the policy has no conditional role bindings, the response uses version 1. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
|
|
2736
|
+
* 'options.requestedPolicyVersion': 'placeholder-value',
|
|
2737
|
+
* // REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.
|
|
2738
|
+
* resource:
|
|
2739
|
+
* 'projects/my-project/locations/my-location/repositories/my-repositorie',
|
|
2740
|
+
* });
|
|
2741
|
+
* console.log(res.data);
|
|
2742
|
+
*
|
|
2743
|
+
* // Example response
|
|
2744
|
+
* // {
|
|
2745
|
+
* // "bindings": [],
|
|
2746
|
+
* // "etag": "my_etag",
|
|
2747
|
+
* // "version": 0
|
|
2748
|
+
* // }
|
|
2749
|
+
* }
|
|
2750
|
+
*
|
|
2751
|
+
* main().catch(e => {
|
|
2752
|
+
* console.error(e);
|
|
2753
|
+
* throw e;
|
|
2754
|
+
* });
|
|
2755
|
+
*
|
|
2756
|
+
* ```
|
|
2074
2757
|
*
|
|
2075
2758
|
* @param params - Parameters for request
|
|
2076
2759
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2077
2760
|
* @param callback - Optional callback that handles the response.
|
|
2078
2761
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2079
2762
|
*/
|
|
2080
|
-
getIamPolicy(params: Params$Resource$Projects$Locations$Repositories$Getiampolicy, options: StreamMethodOptions):
|
|
2081
|
-
getIamPolicy(params?: Params$Resource$Projects$Locations$Repositories$Getiampolicy, options?: MethodOptions):
|
|
2763
|
+
getIamPolicy(params: Params$Resource$Projects$Locations$Repositories$Getiampolicy, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
2764
|
+
getIamPolicy(params?: Params$Resource$Projects$Locations$Repositories$Getiampolicy, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Policy>>;
|
|
2082
2765
|
getIamPolicy(params: Params$Resource$Projects$Locations$Repositories$Getiampolicy, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2083
2766
|
getIamPolicy(params: Params$Resource$Projects$Locations$Repositories$Getiampolicy, options: MethodOptions | BodyResponseCallback<Schema$Policy>, callback: BodyResponseCallback<Schema$Policy>): void;
|
|
2084
2767
|
getIamPolicy(params: Params$Resource$Projects$Locations$Repositories$Getiampolicy, callback: BodyResponseCallback<Schema$Policy>): void;
|
|
2085
2768
|
getIamPolicy(callback: BodyResponseCallback<Schema$Policy>): void;
|
|
2086
2769
|
/**
|
|
2087
2770
|
* Lists Repositories in a given project and location. **Note:** *This method can return repositories not shown in the [Dataform UI](https://console.cloud.google.com/bigquery/dataform)*.
|
|
2771
|
+
* @example
|
|
2772
|
+
* ```js
|
|
2773
|
+
* // Before running the sample:
|
|
2774
|
+
* // - Enable the API at:
|
|
2775
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
2776
|
+
* // - Login into gcloud by running:
|
|
2777
|
+
* // ```sh
|
|
2778
|
+
* // $ gcloud auth application-default login
|
|
2779
|
+
* // ```
|
|
2780
|
+
* // - Install the npm module by running:
|
|
2781
|
+
* // ```sh
|
|
2782
|
+
* // $ npm install googleapis
|
|
2783
|
+
* // ```
|
|
2784
|
+
*
|
|
2785
|
+
* const {google} = require('googleapis');
|
|
2786
|
+
* const dataform = google.dataform('v1beta1');
|
|
2787
|
+
*
|
|
2788
|
+
* async function main() {
|
|
2789
|
+
* const auth = new google.auth.GoogleAuth({
|
|
2790
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
2791
|
+
* scopes: [
|
|
2792
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
2793
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
2794
|
+
* ],
|
|
2795
|
+
* });
|
|
2796
|
+
*
|
|
2797
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
2798
|
+
* const authClient = await auth.getClient();
|
|
2799
|
+
* google.options({auth: authClient});
|
|
2800
|
+
*
|
|
2801
|
+
* // Do the magic
|
|
2802
|
+
* const res = await dataform.projects.locations.repositories.list({
|
|
2803
|
+
* // Optional. Filter for the returned list.
|
|
2804
|
+
* filter: 'placeholder-value',
|
|
2805
|
+
* // Optional. This field only supports ordering by `name`. If unspecified, the server will choose the ordering. If specified, the default order is ascending for the `name` field.
|
|
2806
|
+
* orderBy: 'placeholder-value',
|
|
2807
|
+
* // Optional. Maximum number of repositories to return. The server may return fewer items than requested. If unspecified, the server will pick an appropriate default.
|
|
2808
|
+
* pageSize: 'placeholder-value',
|
|
2809
|
+
* // Optional. Page token received from a previous `ListRepositories` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListRepositories`, with the exception of `page_size`, must match the call that provided the page token.
|
|
2810
|
+
* pageToken: 'placeholder-value',
|
|
2811
|
+
* // Required. The location in which to list repositories. Must be in the format `projects/x/locations/x`.
|
|
2812
|
+
* parent: 'projects/my-project/locations/my-location',
|
|
2813
|
+
* });
|
|
2814
|
+
* console.log(res.data);
|
|
2815
|
+
*
|
|
2816
|
+
* // Example response
|
|
2817
|
+
* // {
|
|
2818
|
+
* // "nextPageToken": "my_nextPageToken",
|
|
2819
|
+
* // "repositories": [],
|
|
2820
|
+
* // "unreachable": []
|
|
2821
|
+
* // }
|
|
2822
|
+
* }
|
|
2823
|
+
*
|
|
2824
|
+
* main().catch(e => {
|
|
2825
|
+
* console.error(e);
|
|
2826
|
+
* throw e;
|
|
2827
|
+
* });
|
|
2828
|
+
*
|
|
2829
|
+
* ```
|
|
2088
2830
|
*
|
|
2089
2831
|
* @param params - Parameters for request
|
|
2090
2832
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2091
2833
|
* @param callback - Optional callback that handles the response.
|
|
2092
2834
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2093
2835
|
*/
|
|
2094
|
-
list(params: Params$Resource$Projects$Locations$Repositories$List, options: StreamMethodOptions):
|
|
2095
|
-
list(params?: Params$Resource$Projects$Locations$Repositories$List, options?: MethodOptions):
|
|
2836
|
+
list(params: Params$Resource$Projects$Locations$Repositories$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
2837
|
+
list(params?: Params$Resource$Projects$Locations$Repositories$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListRepositoriesResponse>>;
|
|
2096
2838
|
list(params: Params$Resource$Projects$Locations$Repositories$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2097
2839
|
list(params: Params$Resource$Projects$Locations$Repositories$List, options: MethodOptions | BodyResponseCallback<Schema$ListRepositoriesResponse>, callback: BodyResponseCallback<Schema$ListRepositoriesResponse>): void;
|
|
2098
2840
|
list(params: Params$Resource$Projects$Locations$Repositories$List, callback: BodyResponseCallback<Schema$ListRepositoriesResponse>): void;
|
|
2099
2841
|
list(callback: BodyResponseCallback<Schema$ListRepositoriesResponse>): void;
|
|
2100
2842
|
/**
|
|
2101
2843
|
* Updates a single Repository. **Note:** *This method does not fully implement [AIP/134](https://google.aip.dev/134). The wildcard entry (\*) is treated as a bad request, and when the `field_mask` is omitted, the request is treated as a full update on all modifiable fields.*
|
|
2844
|
+
* @example
|
|
2845
|
+
* ```js
|
|
2846
|
+
* // Before running the sample:
|
|
2847
|
+
* // - Enable the API at:
|
|
2848
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
2849
|
+
* // - Login into gcloud by running:
|
|
2850
|
+
* // ```sh
|
|
2851
|
+
* // $ gcloud auth application-default login
|
|
2852
|
+
* // ```
|
|
2853
|
+
* // - Install the npm module by running:
|
|
2854
|
+
* // ```sh
|
|
2855
|
+
* // $ npm install googleapis
|
|
2856
|
+
* // ```
|
|
2857
|
+
*
|
|
2858
|
+
* const {google} = require('googleapis');
|
|
2859
|
+
* const dataform = google.dataform('v1beta1');
|
|
2860
|
+
*
|
|
2861
|
+
* async function main() {
|
|
2862
|
+
* const auth = new google.auth.GoogleAuth({
|
|
2863
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
2864
|
+
* scopes: [
|
|
2865
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
2866
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
2867
|
+
* ],
|
|
2868
|
+
* });
|
|
2869
|
+
*
|
|
2870
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
2871
|
+
* const authClient = await auth.getClient();
|
|
2872
|
+
* google.options({auth: authClient});
|
|
2873
|
+
*
|
|
2874
|
+
* // Do the magic
|
|
2875
|
+
* const res = await dataform.projects.locations.repositories.patch({
|
|
2876
|
+
* // Identifier. The repository's name.
|
|
2877
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie',
|
|
2878
|
+
* // Optional. Specifies the fields to be updated in the repository. If left unset, all fields will be updated.
|
|
2879
|
+
* updateMask: 'placeholder-value',
|
|
2880
|
+
*
|
|
2881
|
+
* // Request body metadata
|
|
2882
|
+
* requestBody: {
|
|
2883
|
+
* // request body parameters
|
|
2884
|
+
* // {
|
|
2885
|
+
* // "createTime": "my_createTime",
|
|
2886
|
+
* // "dataEncryptionState": {},
|
|
2887
|
+
* // "displayName": "my_displayName",
|
|
2888
|
+
* // "gitRemoteSettings": {},
|
|
2889
|
+
* // "internalMetadata": "my_internalMetadata",
|
|
2890
|
+
* // "kmsKeyName": "my_kmsKeyName",
|
|
2891
|
+
* // "labels": {},
|
|
2892
|
+
* // "name": "my_name",
|
|
2893
|
+
* // "npmrcEnvironmentVariablesSecretVersion": "my_npmrcEnvironmentVariablesSecretVersion",
|
|
2894
|
+
* // "serviceAccount": "my_serviceAccount",
|
|
2895
|
+
* // "setAuthenticatedUserAdmin": false,
|
|
2896
|
+
* // "workspaceCompilationOverrides": {}
|
|
2897
|
+
* // }
|
|
2898
|
+
* },
|
|
2899
|
+
* });
|
|
2900
|
+
* console.log(res.data);
|
|
2901
|
+
*
|
|
2902
|
+
* // Example response
|
|
2903
|
+
* // {
|
|
2904
|
+
* // "createTime": "my_createTime",
|
|
2905
|
+
* // "dataEncryptionState": {},
|
|
2906
|
+
* // "displayName": "my_displayName",
|
|
2907
|
+
* // "gitRemoteSettings": {},
|
|
2908
|
+
* // "internalMetadata": "my_internalMetadata",
|
|
2909
|
+
* // "kmsKeyName": "my_kmsKeyName",
|
|
2910
|
+
* // "labels": {},
|
|
2911
|
+
* // "name": "my_name",
|
|
2912
|
+
* // "npmrcEnvironmentVariablesSecretVersion": "my_npmrcEnvironmentVariablesSecretVersion",
|
|
2913
|
+
* // "serviceAccount": "my_serviceAccount",
|
|
2914
|
+
* // "setAuthenticatedUserAdmin": false,
|
|
2915
|
+
* // "workspaceCompilationOverrides": {}
|
|
2916
|
+
* // }
|
|
2917
|
+
* }
|
|
2918
|
+
*
|
|
2919
|
+
* main().catch(e => {
|
|
2920
|
+
* console.error(e);
|
|
2921
|
+
* throw e;
|
|
2922
|
+
* });
|
|
2923
|
+
*
|
|
2924
|
+
* ```
|
|
2102
2925
|
*
|
|
2103
2926
|
* @param params - Parameters for request
|
|
2104
2927
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2105
2928
|
* @param callback - Optional callback that handles the response.
|
|
2106
2929
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2107
2930
|
*/
|
|
2108
|
-
patch(params: Params$Resource$Projects$Locations$Repositories$Patch, options: StreamMethodOptions):
|
|
2109
|
-
patch(params?: Params$Resource$Projects$Locations$Repositories$Patch, options?: MethodOptions):
|
|
2931
|
+
patch(params: Params$Resource$Projects$Locations$Repositories$Patch, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
2932
|
+
patch(params?: Params$Resource$Projects$Locations$Repositories$Patch, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Repository>>;
|
|
2110
2933
|
patch(params: Params$Resource$Projects$Locations$Repositories$Patch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2111
2934
|
patch(params: Params$Resource$Projects$Locations$Repositories$Patch, options: MethodOptions | BodyResponseCallback<Schema$Repository>, callback: BodyResponseCallback<Schema$Repository>): void;
|
|
2112
2935
|
patch(params: Params$Resource$Projects$Locations$Repositories$Patch, callback: BodyResponseCallback<Schema$Repository>): void;
|
|
2113
2936
|
patch(callback: BodyResponseCallback<Schema$Repository>): void;
|
|
2114
2937
|
/**
|
|
2115
2938
|
* Returns the contents of a given Repository directory. The Repository must not have a value for `git_remote_settings.url`.
|
|
2939
|
+
* @example
|
|
2940
|
+
* ```js
|
|
2941
|
+
* // Before running the sample:
|
|
2942
|
+
* // - Enable the API at:
|
|
2943
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
2944
|
+
* // - Login into gcloud by running:
|
|
2945
|
+
* // ```sh
|
|
2946
|
+
* // $ gcloud auth application-default login
|
|
2947
|
+
* // ```
|
|
2948
|
+
* // - Install the npm module by running:
|
|
2949
|
+
* // ```sh
|
|
2950
|
+
* // $ npm install googleapis
|
|
2951
|
+
* // ```
|
|
2952
|
+
*
|
|
2953
|
+
* const {google} = require('googleapis');
|
|
2954
|
+
* const dataform = google.dataform('v1beta1');
|
|
2955
|
+
*
|
|
2956
|
+
* async function main() {
|
|
2957
|
+
* const auth = new google.auth.GoogleAuth({
|
|
2958
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
2959
|
+
* scopes: [
|
|
2960
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
2961
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
2962
|
+
* ],
|
|
2963
|
+
* });
|
|
2964
|
+
*
|
|
2965
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
2966
|
+
* const authClient = await auth.getClient();
|
|
2967
|
+
* google.options({auth: authClient});
|
|
2968
|
+
*
|
|
2969
|
+
* // Do the magic
|
|
2970
|
+
* const res =
|
|
2971
|
+
* await dataform.projects.locations.repositories.queryDirectoryContents({
|
|
2972
|
+
* // Optional. The Commit SHA for the commit to query from. If unset, the directory will be queried from HEAD.
|
|
2973
|
+
* commitSha: 'placeholder-value',
|
|
2974
|
+
* // Required. The repository's name.
|
|
2975
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie',
|
|
2976
|
+
* // Optional. Maximum number of paths to return. The server may return fewer items than requested. If unspecified, the server will pick an appropriate default.
|
|
2977
|
+
* pageSize: 'placeholder-value',
|
|
2978
|
+
* // Optional. Page token received from a previous `QueryRepositoryDirectoryContents` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `QueryRepositoryDirectoryContents`, with the exception of `page_size`, must match the call that provided the page token.
|
|
2979
|
+
* pageToken: 'placeholder-value',
|
|
2980
|
+
* // Optional. The directory's full path including directory name, relative to root. If left unset, the root is used.
|
|
2981
|
+
* path: 'placeholder-value',
|
|
2982
|
+
* });
|
|
2983
|
+
* console.log(res.data);
|
|
2984
|
+
*
|
|
2985
|
+
* // Example response
|
|
2986
|
+
* // {
|
|
2987
|
+
* // "directoryEntries": [],
|
|
2988
|
+
* // "nextPageToken": "my_nextPageToken"
|
|
2989
|
+
* // }
|
|
2990
|
+
* }
|
|
2991
|
+
*
|
|
2992
|
+
* main().catch(e => {
|
|
2993
|
+
* console.error(e);
|
|
2994
|
+
* throw e;
|
|
2995
|
+
* });
|
|
2996
|
+
*
|
|
2997
|
+
* ```
|
|
2116
2998
|
*
|
|
2117
2999
|
* @param params - Parameters for request
|
|
2118
3000
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2119
3001
|
* @param callback - Optional callback that handles the response.
|
|
2120
3002
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2121
3003
|
*/
|
|
2122
|
-
queryDirectoryContents(params: Params$Resource$Projects$Locations$Repositories$Querydirectorycontents, options: StreamMethodOptions):
|
|
2123
|
-
queryDirectoryContents(params?: Params$Resource$Projects$Locations$Repositories$Querydirectorycontents, options?: MethodOptions):
|
|
3004
|
+
queryDirectoryContents(params: Params$Resource$Projects$Locations$Repositories$Querydirectorycontents, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
3005
|
+
queryDirectoryContents(params?: Params$Resource$Projects$Locations$Repositories$Querydirectorycontents, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$QueryRepositoryDirectoryContentsResponse>>;
|
|
2124
3006
|
queryDirectoryContents(params: Params$Resource$Projects$Locations$Repositories$Querydirectorycontents, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2125
3007
|
queryDirectoryContents(params: Params$Resource$Projects$Locations$Repositories$Querydirectorycontents, options: MethodOptions | BodyResponseCallback<Schema$QueryRepositoryDirectoryContentsResponse>, callback: BodyResponseCallback<Schema$QueryRepositoryDirectoryContentsResponse>): void;
|
|
2126
3008
|
queryDirectoryContents(params: Params$Resource$Projects$Locations$Repositories$Querydirectorycontents, callback: BodyResponseCallback<Schema$QueryRepositoryDirectoryContentsResponse>): void;
|
|
2127
3009
|
queryDirectoryContents(callback: BodyResponseCallback<Schema$QueryRepositoryDirectoryContentsResponse>): void;
|
|
2128
3010
|
/**
|
|
2129
3011
|
* Returns the contents of a file (inside a Repository). The Repository must not have a value for `git_remote_settings.url`.
|
|
3012
|
+
* @example
|
|
3013
|
+
* ```js
|
|
3014
|
+
* // Before running the sample:
|
|
3015
|
+
* // - Enable the API at:
|
|
3016
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
3017
|
+
* // - Login into gcloud by running:
|
|
3018
|
+
* // ```sh
|
|
3019
|
+
* // $ gcloud auth application-default login
|
|
3020
|
+
* // ```
|
|
3021
|
+
* // - Install the npm module by running:
|
|
3022
|
+
* // ```sh
|
|
3023
|
+
* // $ npm install googleapis
|
|
3024
|
+
* // ```
|
|
3025
|
+
*
|
|
3026
|
+
* const {google} = require('googleapis');
|
|
3027
|
+
* const dataform = google.dataform('v1beta1');
|
|
3028
|
+
*
|
|
3029
|
+
* async function main() {
|
|
3030
|
+
* const auth = new google.auth.GoogleAuth({
|
|
3031
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
3032
|
+
* scopes: [
|
|
3033
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
3034
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
3035
|
+
* ],
|
|
3036
|
+
* });
|
|
3037
|
+
*
|
|
3038
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
3039
|
+
* const authClient = await auth.getClient();
|
|
3040
|
+
* google.options({auth: authClient});
|
|
3041
|
+
*
|
|
3042
|
+
* // Do the magic
|
|
3043
|
+
* const res = await dataform.projects.locations.repositories.readFile({
|
|
3044
|
+
* // Optional. The commit SHA for the commit to read from. If unset, the file will be read from HEAD.
|
|
3045
|
+
* commitSha: 'placeholder-value',
|
|
3046
|
+
* // Required. The repository's name.
|
|
3047
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie',
|
|
3048
|
+
* // Required. Full file path to read including filename, from repository root.
|
|
3049
|
+
* path: 'placeholder-value',
|
|
3050
|
+
* });
|
|
3051
|
+
* console.log(res.data);
|
|
3052
|
+
*
|
|
3053
|
+
* // Example response
|
|
3054
|
+
* // {
|
|
3055
|
+
* // "contents": "my_contents"
|
|
3056
|
+
* // }
|
|
3057
|
+
* }
|
|
3058
|
+
*
|
|
3059
|
+
* main().catch(e => {
|
|
3060
|
+
* console.error(e);
|
|
3061
|
+
* throw e;
|
|
3062
|
+
* });
|
|
3063
|
+
*
|
|
3064
|
+
* ```
|
|
2130
3065
|
*
|
|
2131
3066
|
* @param params - Parameters for request
|
|
2132
3067
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2133
3068
|
* @param callback - Optional callback that handles the response.
|
|
2134
3069
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2135
3070
|
*/
|
|
2136
|
-
readFile(params: Params$Resource$Projects$Locations$Repositories$Readfile, options: StreamMethodOptions):
|
|
2137
|
-
readFile(params?: Params$Resource$Projects$Locations$Repositories$Readfile, options?: MethodOptions):
|
|
3071
|
+
readFile(params: Params$Resource$Projects$Locations$Repositories$Readfile, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
3072
|
+
readFile(params?: Params$Resource$Projects$Locations$Repositories$Readfile, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ReadRepositoryFileResponse>>;
|
|
2138
3073
|
readFile(params: Params$Resource$Projects$Locations$Repositories$Readfile, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2139
3074
|
readFile(params: Params$Resource$Projects$Locations$Repositories$Readfile, options: MethodOptions | BodyResponseCallback<Schema$ReadRepositoryFileResponse>, callback: BodyResponseCallback<Schema$ReadRepositoryFileResponse>): void;
|
|
2140
3075
|
readFile(params: Params$Resource$Projects$Locations$Repositories$Readfile, callback: BodyResponseCallback<Schema$ReadRepositoryFileResponse>): void;
|
|
2141
3076
|
readFile(callback: BodyResponseCallback<Schema$ReadRepositoryFileResponse>): void;
|
|
2142
3077
|
/**
|
|
2143
3078
|
* Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.
|
|
3079
|
+
* @example
|
|
3080
|
+
* ```js
|
|
3081
|
+
* // Before running the sample:
|
|
3082
|
+
* // - Enable the API at:
|
|
3083
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
3084
|
+
* // - Login into gcloud by running:
|
|
3085
|
+
* // ```sh
|
|
3086
|
+
* // $ gcloud auth application-default login
|
|
3087
|
+
* // ```
|
|
3088
|
+
* // - Install the npm module by running:
|
|
3089
|
+
* // ```sh
|
|
3090
|
+
* // $ npm install googleapis
|
|
3091
|
+
* // ```
|
|
3092
|
+
*
|
|
3093
|
+
* const {google} = require('googleapis');
|
|
3094
|
+
* const dataform = google.dataform('v1beta1');
|
|
3095
|
+
*
|
|
3096
|
+
* async function main() {
|
|
3097
|
+
* const auth = new google.auth.GoogleAuth({
|
|
3098
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
3099
|
+
* scopes: [
|
|
3100
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
3101
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
3102
|
+
* ],
|
|
3103
|
+
* });
|
|
3104
|
+
*
|
|
3105
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
3106
|
+
* const authClient = await auth.getClient();
|
|
3107
|
+
* google.options({auth: authClient});
|
|
3108
|
+
*
|
|
3109
|
+
* // Do the magic
|
|
3110
|
+
* const res = await dataform.projects.locations.repositories.setIamPolicy({
|
|
3111
|
+
* // REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.
|
|
3112
|
+
* resource:
|
|
3113
|
+
* 'projects/my-project/locations/my-location/repositories/my-repositorie',
|
|
3114
|
+
*
|
|
3115
|
+
* // Request body metadata
|
|
3116
|
+
* requestBody: {
|
|
3117
|
+
* // request body parameters
|
|
3118
|
+
* // {
|
|
3119
|
+
* // "policy": {}
|
|
3120
|
+
* // }
|
|
3121
|
+
* },
|
|
3122
|
+
* });
|
|
3123
|
+
* console.log(res.data);
|
|
3124
|
+
*
|
|
3125
|
+
* // Example response
|
|
3126
|
+
* // {
|
|
3127
|
+
* // "bindings": [],
|
|
3128
|
+
* // "etag": "my_etag",
|
|
3129
|
+
* // "version": 0
|
|
3130
|
+
* // }
|
|
3131
|
+
* }
|
|
3132
|
+
*
|
|
3133
|
+
* main().catch(e => {
|
|
3134
|
+
* console.error(e);
|
|
3135
|
+
* throw e;
|
|
3136
|
+
* });
|
|
3137
|
+
*
|
|
3138
|
+
* ```
|
|
2144
3139
|
*
|
|
2145
3140
|
* @param params - Parameters for request
|
|
2146
3141
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2147
3142
|
* @param callback - Optional callback that handles the response.
|
|
2148
3143
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2149
3144
|
*/
|
|
2150
|
-
setIamPolicy(params: Params$Resource$Projects$Locations$Repositories$Setiampolicy, options: StreamMethodOptions):
|
|
2151
|
-
setIamPolicy(params?: Params$Resource$Projects$Locations$Repositories$Setiampolicy, options?: MethodOptions):
|
|
3145
|
+
setIamPolicy(params: Params$Resource$Projects$Locations$Repositories$Setiampolicy, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
3146
|
+
setIamPolicy(params?: Params$Resource$Projects$Locations$Repositories$Setiampolicy, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Policy>>;
|
|
2152
3147
|
setIamPolicy(params: Params$Resource$Projects$Locations$Repositories$Setiampolicy, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2153
3148
|
setIamPolicy(params: Params$Resource$Projects$Locations$Repositories$Setiampolicy, options: MethodOptions | BodyResponseCallback<Schema$Policy>, callback: BodyResponseCallback<Schema$Policy>): void;
|
|
2154
3149
|
setIamPolicy(params: Params$Resource$Projects$Locations$Repositories$Setiampolicy, callback: BodyResponseCallback<Schema$Policy>): void;
|
|
2155
3150
|
setIamPolicy(callback: BodyResponseCallback<Schema$Policy>): void;
|
|
2156
3151
|
/**
|
|
2157
3152
|
* Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may "fail open" without warning.
|
|
3153
|
+
* @example
|
|
3154
|
+
* ```js
|
|
3155
|
+
* // Before running the sample:
|
|
3156
|
+
* // - Enable the API at:
|
|
3157
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
3158
|
+
* // - Login into gcloud by running:
|
|
3159
|
+
* // ```sh
|
|
3160
|
+
* // $ gcloud auth application-default login
|
|
3161
|
+
* // ```
|
|
3162
|
+
* // - Install the npm module by running:
|
|
3163
|
+
* // ```sh
|
|
3164
|
+
* // $ npm install googleapis
|
|
3165
|
+
* // ```
|
|
3166
|
+
*
|
|
3167
|
+
* const {google} = require('googleapis');
|
|
3168
|
+
* const dataform = google.dataform('v1beta1');
|
|
3169
|
+
*
|
|
3170
|
+
* async function main() {
|
|
3171
|
+
* const auth = new google.auth.GoogleAuth({
|
|
3172
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
3173
|
+
* scopes: [
|
|
3174
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
3175
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
3176
|
+
* ],
|
|
3177
|
+
* });
|
|
3178
|
+
*
|
|
3179
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
3180
|
+
* const authClient = await auth.getClient();
|
|
3181
|
+
* google.options({auth: authClient});
|
|
3182
|
+
*
|
|
3183
|
+
* // Do the magic
|
|
3184
|
+
* const res = await dataform.projects.locations.repositories.testIamPermissions(
|
|
3185
|
+
* {
|
|
3186
|
+
* // REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.
|
|
3187
|
+
* resource:
|
|
3188
|
+
* 'projects/my-project/locations/my-location/repositories/my-repositorie',
|
|
3189
|
+
*
|
|
3190
|
+
* // Request body metadata
|
|
3191
|
+
* requestBody: {
|
|
3192
|
+
* // request body parameters
|
|
3193
|
+
* // {
|
|
3194
|
+
* // "permissions": []
|
|
3195
|
+
* // }
|
|
3196
|
+
* },
|
|
3197
|
+
* },
|
|
3198
|
+
* );
|
|
3199
|
+
* console.log(res.data);
|
|
3200
|
+
*
|
|
3201
|
+
* // Example response
|
|
3202
|
+
* // {
|
|
3203
|
+
* // "permissions": []
|
|
3204
|
+
* // }
|
|
3205
|
+
* }
|
|
3206
|
+
*
|
|
3207
|
+
* main().catch(e => {
|
|
3208
|
+
* console.error(e);
|
|
3209
|
+
* throw e;
|
|
3210
|
+
* });
|
|
3211
|
+
*
|
|
3212
|
+
* ```
|
|
2158
3213
|
*
|
|
2159
3214
|
* @param params - Parameters for request
|
|
2160
3215
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2161
3216
|
* @param callback - Optional callback that handles the response.
|
|
2162
3217
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2163
3218
|
*/
|
|
2164
|
-
testIamPermissions(params: Params$Resource$Projects$Locations$Repositories$Testiampermissions, options: StreamMethodOptions):
|
|
2165
|
-
testIamPermissions(params?: Params$Resource$Projects$Locations$Repositories$Testiampermissions, options?: MethodOptions):
|
|
3219
|
+
testIamPermissions(params: Params$Resource$Projects$Locations$Repositories$Testiampermissions, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
3220
|
+
testIamPermissions(params?: Params$Resource$Projects$Locations$Repositories$Testiampermissions, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$TestIamPermissionsResponse>>;
|
|
2166
3221
|
testIamPermissions(params: Params$Resource$Projects$Locations$Repositories$Testiampermissions, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2167
3222
|
testIamPermissions(params: Params$Resource$Projects$Locations$Repositories$Testiampermissions, options: MethodOptions | BodyResponseCallback<Schema$TestIamPermissionsResponse>, callback: BodyResponseCallback<Schema$TestIamPermissionsResponse>): void;
|
|
2168
3223
|
testIamPermissions(params: Params$Resource$Projects$Locations$Repositories$Testiampermissions, callback: BodyResponseCallback<Schema$TestIamPermissionsResponse>): void;
|
|
@@ -2200,7 +3255,7 @@ export declare namespace dataform_v1beta1 {
|
|
|
2200
3255
|
}
|
|
2201
3256
|
export interface Params$Resource$Projects$Locations$Repositories$Delete extends StandardParameters {
|
|
2202
3257
|
/**
|
|
2203
|
-
* Optional. If set to true,
|
|
3258
|
+
* Optional. If set to true, child resources of this repository (compilation results and workflow invocations) will also be deleted. Otherwise, the request will only succeed if the repository has no child resources. **Note:** *This flag doesn't support deletion of workspaces, release configs or workflow configs. If any of such resources exists in the repository, the request will fail.*.
|
|
2204
3259
|
*/
|
|
2205
3260
|
force?: boolean;
|
|
2206
3261
|
/**
|
|
@@ -2341,56 +3396,313 @@ export declare namespace dataform_v1beta1 {
|
|
|
2341
3396
|
constructor(context: APIRequestContext);
|
|
2342
3397
|
/**
|
|
2343
3398
|
* Creates a new CompilationResult in a given project and location.
|
|
3399
|
+
* @example
|
|
3400
|
+
* ```js
|
|
3401
|
+
* // Before running the sample:
|
|
3402
|
+
* // - Enable the API at:
|
|
3403
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
3404
|
+
* // - Login into gcloud by running:
|
|
3405
|
+
* // ```sh
|
|
3406
|
+
* // $ gcloud auth application-default login
|
|
3407
|
+
* // ```
|
|
3408
|
+
* // - Install the npm module by running:
|
|
3409
|
+
* // ```sh
|
|
3410
|
+
* // $ npm install googleapis
|
|
3411
|
+
* // ```
|
|
3412
|
+
*
|
|
3413
|
+
* const {google} = require('googleapis');
|
|
3414
|
+
* const dataform = google.dataform('v1beta1');
|
|
3415
|
+
*
|
|
3416
|
+
* async function main() {
|
|
3417
|
+
* const auth = new google.auth.GoogleAuth({
|
|
3418
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
3419
|
+
* scopes: [
|
|
3420
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
3421
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
3422
|
+
* ],
|
|
3423
|
+
* });
|
|
3424
|
+
*
|
|
3425
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
3426
|
+
* const authClient = await auth.getClient();
|
|
3427
|
+
* google.options({auth: authClient});
|
|
3428
|
+
*
|
|
3429
|
+
* // Do the magic
|
|
3430
|
+
* const res =
|
|
3431
|
+
* await dataform.projects.locations.repositories.compilationResults.create({
|
|
3432
|
+
* // Required. The repository in which to create the compilation result. Must be in the format `projects/x/locations/x/repositories/x`.
|
|
3433
|
+
* parent:
|
|
3434
|
+
* 'projects/my-project/locations/my-location/repositories/my-repositorie',
|
|
3435
|
+
*
|
|
3436
|
+
* // Request body metadata
|
|
3437
|
+
* requestBody: {
|
|
3438
|
+
* // request body parameters
|
|
3439
|
+
* // {
|
|
3440
|
+
* // "codeCompilationConfig": {},
|
|
3441
|
+
* // "compilationErrors": [],
|
|
3442
|
+
* // "createTime": "my_createTime",
|
|
3443
|
+
* // "dataEncryptionState": {},
|
|
3444
|
+
* // "dataformCoreVersion": "my_dataformCoreVersion",
|
|
3445
|
+
* // "gitCommitish": "my_gitCommitish",
|
|
3446
|
+
* // "internalMetadata": "my_internalMetadata",
|
|
3447
|
+
* // "name": "my_name",
|
|
3448
|
+
* // "releaseConfig": "my_releaseConfig",
|
|
3449
|
+
* // "resolvedGitCommitSha": "my_resolvedGitCommitSha",
|
|
3450
|
+
* // "workspace": "my_workspace"
|
|
3451
|
+
* // }
|
|
3452
|
+
* },
|
|
3453
|
+
* });
|
|
3454
|
+
* console.log(res.data);
|
|
3455
|
+
*
|
|
3456
|
+
* // Example response
|
|
3457
|
+
* // {
|
|
3458
|
+
* // "codeCompilationConfig": {},
|
|
3459
|
+
* // "compilationErrors": [],
|
|
3460
|
+
* // "createTime": "my_createTime",
|
|
3461
|
+
* // "dataEncryptionState": {},
|
|
3462
|
+
* // "dataformCoreVersion": "my_dataformCoreVersion",
|
|
3463
|
+
* // "gitCommitish": "my_gitCommitish",
|
|
3464
|
+
* // "internalMetadata": "my_internalMetadata",
|
|
3465
|
+
* // "name": "my_name",
|
|
3466
|
+
* // "releaseConfig": "my_releaseConfig",
|
|
3467
|
+
* // "resolvedGitCommitSha": "my_resolvedGitCommitSha",
|
|
3468
|
+
* // "workspace": "my_workspace"
|
|
3469
|
+
* // }
|
|
3470
|
+
* }
|
|
3471
|
+
*
|
|
3472
|
+
* main().catch(e => {
|
|
3473
|
+
* console.error(e);
|
|
3474
|
+
* throw e;
|
|
3475
|
+
* });
|
|
3476
|
+
*
|
|
3477
|
+
* ```
|
|
2344
3478
|
*
|
|
2345
3479
|
* @param params - Parameters for request
|
|
2346
3480
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2347
3481
|
* @param callback - Optional callback that handles the response.
|
|
2348
3482
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2349
3483
|
*/
|
|
2350
|
-
create(params: Params$Resource$Projects$Locations$Repositories$Compilationresults$Create, options: StreamMethodOptions):
|
|
2351
|
-
create(params?: Params$Resource$Projects$Locations$Repositories$Compilationresults$Create, options?: MethodOptions):
|
|
3484
|
+
create(params: Params$Resource$Projects$Locations$Repositories$Compilationresults$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
3485
|
+
create(params?: Params$Resource$Projects$Locations$Repositories$Compilationresults$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$CompilationResult>>;
|
|
2352
3486
|
create(params: Params$Resource$Projects$Locations$Repositories$Compilationresults$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2353
3487
|
create(params: Params$Resource$Projects$Locations$Repositories$Compilationresults$Create, options: MethodOptions | BodyResponseCallback<Schema$CompilationResult>, callback: BodyResponseCallback<Schema$CompilationResult>): void;
|
|
2354
3488
|
create(params: Params$Resource$Projects$Locations$Repositories$Compilationresults$Create, callback: BodyResponseCallback<Schema$CompilationResult>): void;
|
|
2355
3489
|
create(callback: BodyResponseCallback<Schema$CompilationResult>): void;
|
|
2356
3490
|
/**
|
|
2357
3491
|
* Fetches a single CompilationResult.
|
|
3492
|
+
* @example
|
|
3493
|
+
* ```js
|
|
3494
|
+
* // Before running the sample:
|
|
3495
|
+
* // - Enable the API at:
|
|
3496
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
3497
|
+
* // - Login into gcloud by running:
|
|
3498
|
+
* // ```sh
|
|
3499
|
+
* // $ gcloud auth application-default login
|
|
3500
|
+
* // ```
|
|
3501
|
+
* // - Install the npm module by running:
|
|
3502
|
+
* // ```sh
|
|
3503
|
+
* // $ npm install googleapis
|
|
3504
|
+
* // ```
|
|
3505
|
+
*
|
|
3506
|
+
* const {google} = require('googleapis');
|
|
3507
|
+
* const dataform = google.dataform('v1beta1');
|
|
3508
|
+
*
|
|
3509
|
+
* async function main() {
|
|
3510
|
+
* const auth = new google.auth.GoogleAuth({
|
|
3511
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
3512
|
+
* scopes: [
|
|
3513
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
3514
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
3515
|
+
* ],
|
|
3516
|
+
* });
|
|
3517
|
+
*
|
|
3518
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
3519
|
+
* const authClient = await auth.getClient();
|
|
3520
|
+
* google.options({auth: authClient});
|
|
3521
|
+
*
|
|
3522
|
+
* // Do the magic
|
|
3523
|
+
* const res =
|
|
3524
|
+
* await dataform.projects.locations.repositories.compilationResults.get({
|
|
3525
|
+
* // Required. The compilation result's name.
|
|
3526
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie/compilationResults/my-compilationResult',
|
|
3527
|
+
* });
|
|
3528
|
+
* console.log(res.data);
|
|
3529
|
+
*
|
|
3530
|
+
* // Example response
|
|
3531
|
+
* // {
|
|
3532
|
+
* // "codeCompilationConfig": {},
|
|
3533
|
+
* // "compilationErrors": [],
|
|
3534
|
+
* // "createTime": "my_createTime",
|
|
3535
|
+
* // "dataEncryptionState": {},
|
|
3536
|
+
* // "dataformCoreVersion": "my_dataformCoreVersion",
|
|
3537
|
+
* // "gitCommitish": "my_gitCommitish",
|
|
3538
|
+
* // "internalMetadata": "my_internalMetadata",
|
|
3539
|
+
* // "name": "my_name",
|
|
3540
|
+
* // "releaseConfig": "my_releaseConfig",
|
|
3541
|
+
* // "resolvedGitCommitSha": "my_resolvedGitCommitSha",
|
|
3542
|
+
* // "workspace": "my_workspace"
|
|
3543
|
+
* // }
|
|
3544
|
+
* }
|
|
3545
|
+
*
|
|
3546
|
+
* main().catch(e => {
|
|
3547
|
+
* console.error(e);
|
|
3548
|
+
* throw e;
|
|
3549
|
+
* });
|
|
3550
|
+
*
|
|
3551
|
+
* ```
|
|
2358
3552
|
*
|
|
2359
3553
|
* @param params - Parameters for request
|
|
2360
3554
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2361
3555
|
* @param callback - Optional callback that handles the response.
|
|
2362
3556
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2363
3557
|
*/
|
|
2364
|
-
get(params: Params$Resource$Projects$Locations$Repositories$Compilationresults$Get, options: StreamMethodOptions):
|
|
2365
|
-
get(params?: Params$Resource$Projects$Locations$Repositories$Compilationresults$Get, options?: MethodOptions):
|
|
3558
|
+
get(params: Params$Resource$Projects$Locations$Repositories$Compilationresults$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
3559
|
+
get(params?: Params$Resource$Projects$Locations$Repositories$Compilationresults$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$CompilationResult>>;
|
|
2366
3560
|
get(params: Params$Resource$Projects$Locations$Repositories$Compilationresults$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2367
3561
|
get(params: Params$Resource$Projects$Locations$Repositories$Compilationresults$Get, options: MethodOptions | BodyResponseCallback<Schema$CompilationResult>, callback: BodyResponseCallback<Schema$CompilationResult>): void;
|
|
2368
3562
|
get(params: Params$Resource$Projects$Locations$Repositories$Compilationresults$Get, callback: BodyResponseCallback<Schema$CompilationResult>): void;
|
|
2369
3563
|
get(callback: BodyResponseCallback<Schema$CompilationResult>): void;
|
|
2370
3564
|
/**
|
|
2371
3565
|
* Lists CompilationResults in a given Repository.
|
|
3566
|
+
* @example
|
|
3567
|
+
* ```js
|
|
3568
|
+
* // Before running the sample:
|
|
3569
|
+
* // - Enable the API at:
|
|
3570
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
3571
|
+
* // - Login into gcloud by running:
|
|
3572
|
+
* // ```sh
|
|
3573
|
+
* // $ gcloud auth application-default login
|
|
3574
|
+
* // ```
|
|
3575
|
+
* // - Install the npm module by running:
|
|
3576
|
+
* // ```sh
|
|
3577
|
+
* // $ npm install googleapis
|
|
3578
|
+
* // ```
|
|
3579
|
+
*
|
|
3580
|
+
* const {google} = require('googleapis');
|
|
3581
|
+
* const dataform = google.dataform('v1beta1');
|
|
3582
|
+
*
|
|
3583
|
+
* async function main() {
|
|
3584
|
+
* const auth = new google.auth.GoogleAuth({
|
|
3585
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
3586
|
+
* scopes: [
|
|
3587
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
3588
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
3589
|
+
* ],
|
|
3590
|
+
* });
|
|
3591
|
+
*
|
|
3592
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
3593
|
+
* const authClient = await auth.getClient();
|
|
3594
|
+
* google.options({auth: authClient});
|
|
3595
|
+
*
|
|
3596
|
+
* // Do the magic
|
|
3597
|
+
* const res =
|
|
3598
|
+
* await dataform.projects.locations.repositories.compilationResults.list({
|
|
3599
|
+
* // Optional. Filter for the returned list.
|
|
3600
|
+
* filter: 'placeholder-value',
|
|
3601
|
+
* // Optional. This field only supports ordering by `name` and `create_time`. If unspecified, the server will choose the ordering. If specified, the default order is ascending for the `name` field.
|
|
3602
|
+
* orderBy: 'placeholder-value',
|
|
3603
|
+
* // Optional. Maximum number of compilation results to return. The server may return fewer items than requested. If unspecified, the server will pick an appropriate default.
|
|
3604
|
+
* pageSize: 'placeholder-value',
|
|
3605
|
+
* // Optional. Page token received from a previous `ListCompilationResults` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListCompilationResults`, with the exception of `page_size`, must match the call that provided the page token.
|
|
3606
|
+
* pageToken: 'placeholder-value',
|
|
3607
|
+
* // Required. The repository in which to list compilation results. Must be in the format `projects/x/locations/x/repositories/x`.
|
|
3608
|
+
* parent:
|
|
3609
|
+
* 'projects/my-project/locations/my-location/repositories/my-repositorie',
|
|
3610
|
+
* });
|
|
3611
|
+
* console.log(res.data);
|
|
3612
|
+
*
|
|
3613
|
+
* // Example response
|
|
3614
|
+
* // {
|
|
3615
|
+
* // "compilationResults": [],
|
|
3616
|
+
* // "nextPageToken": "my_nextPageToken",
|
|
3617
|
+
* // "unreachable": []
|
|
3618
|
+
* // }
|
|
3619
|
+
* }
|
|
3620
|
+
*
|
|
3621
|
+
* main().catch(e => {
|
|
3622
|
+
* console.error(e);
|
|
3623
|
+
* throw e;
|
|
3624
|
+
* });
|
|
3625
|
+
*
|
|
3626
|
+
* ```
|
|
2372
3627
|
*
|
|
2373
3628
|
* @param params - Parameters for request
|
|
2374
3629
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2375
3630
|
* @param callback - Optional callback that handles the response.
|
|
2376
3631
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2377
3632
|
*/
|
|
2378
|
-
list(params: Params$Resource$Projects$Locations$Repositories$Compilationresults$List, options: StreamMethodOptions):
|
|
2379
|
-
list(params?: Params$Resource$Projects$Locations$Repositories$Compilationresults$List, options?: MethodOptions):
|
|
3633
|
+
list(params: Params$Resource$Projects$Locations$Repositories$Compilationresults$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
3634
|
+
list(params?: Params$Resource$Projects$Locations$Repositories$Compilationresults$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListCompilationResultsResponse>>;
|
|
2380
3635
|
list(params: Params$Resource$Projects$Locations$Repositories$Compilationresults$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2381
3636
|
list(params: Params$Resource$Projects$Locations$Repositories$Compilationresults$List, options: MethodOptions | BodyResponseCallback<Schema$ListCompilationResultsResponse>, callback: BodyResponseCallback<Schema$ListCompilationResultsResponse>): void;
|
|
2382
3637
|
list(params: Params$Resource$Projects$Locations$Repositories$Compilationresults$List, callback: BodyResponseCallback<Schema$ListCompilationResultsResponse>): void;
|
|
2383
3638
|
list(callback: BodyResponseCallback<Schema$ListCompilationResultsResponse>): void;
|
|
2384
3639
|
/**
|
|
2385
3640
|
* Returns CompilationResultActions in a given CompilationResult.
|
|
3641
|
+
* @example
|
|
3642
|
+
* ```js
|
|
3643
|
+
* // Before running the sample:
|
|
3644
|
+
* // - Enable the API at:
|
|
3645
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
3646
|
+
* // - Login into gcloud by running:
|
|
3647
|
+
* // ```sh
|
|
3648
|
+
* // $ gcloud auth application-default login
|
|
3649
|
+
* // ```
|
|
3650
|
+
* // - Install the npm module by running:
|
|
3651
|
+
* // ```sh
|
|
3652
|
+
* // $ npm install googleapis
|
|
3653
|
+
* // ```
|
|
3654
|
+
*
|
|
3655
|
+
* const {google} = require('googleapis');
|
|
3656
|
+
* const dataform = google.dataform('v1beta1');
|
|
3657
|
+
*
|
|
3658
|
+
* async function main() {
|
|
3659
|
+
* const auth = new google.auth.GoogleAuth({
|
|
3660
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
3661
|
+
* scopes: [
|
|
3662
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
3663
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
3664
|
+
* ],
|
|
3665
|
+
* });
|
|
3666
|
+
*
|
|
3667
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
3668
|
+
* const authClient = await auth.getClient();
|
|
3669
|
+
* google.options({auth: authClient});
|
|
3670
|
+
*
|
|
3671
|
+
* // Do the magic
|
|
3672
|
+
* const res =
|
|
3673
|
+
* await dataform.projects.locations.repositories.compilationResults.query({
|
|
3674
|
+
* // Optional. Optional filter for the returned list. Filtering is only currently supported on the `file_path` field.
|
|
3675
|
+
* filter: 'placeholder-value',
|
|
3676
|
+
* // Required. The compilation result's name.
|
|
3677
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie/compilationResults/my-compilationResult',
|
|
3678
|
+
* // Optional. Maximum number of compilation results to return. The server may return fewer items than requested. If unspecified, the server will pick an appropriate default.
|
|
3679
|
+
* pageSize: 'placeholder-value',
|
|
3680
|
+
* // Optional. Page token received from a previous `QueryCompilationResultActions` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `QueryCompilationResultActions`, with the exception of `page_size`, must match the call that provided the page token.
|
|
3681
|
+
* pageToken: 'placeholder-value',
|
|
3682
|
+
* });
|
|
3683
|
+
* console.log(res.data);
|
|
3684
|
+
*
|
|
3685
|
+
* // Example response
|
|
3686
|
+
* // {
|
|
3687
|
+
* // "compilationResultActions": [],
|
|
3688
|
+
* // "nextPageToken": "my_nextPageToken"
|
|
3689
|
+
* // }
|
|
3690
|
+
* }
|
|
3691
|
+
*
|
|
3692
|
+
* main().catch(e => {
|
|
3693
|
+
* console.error(e);
|
|
3694
|
+
* throw e;
|
|
3695
|
+
* });
|
|
3696
|
+
*
|
|
3697
|
+
* ```
|
|
2386
3698
|
*
|
|
2387
3699
|
* @param params - Parameters for request
|
|
2388
3700
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2389
3701
|
* @param callback - Optional callback that handles the response.
|
|
2390
3702
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2391
3703
|
*/
|
|
2392
|
-
query(params: Params$Resource$Projects$Locations$Repositories$Compilationresults$Query, options: StreamMethodOptions):
|
|
2393
|
-
query(params?: Params$Resource$Projects$Locations$Repositories$Compilationresults$Query, options?: MethodOptions):
|
|
3704
|
+
query(params: Params$Resource$Projects$Locations$Repositories$Compilationresults$Query, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
3705
|
+
query(params?: Params$Resource$Projects$Locations$Repositories$Compilationresults$Query, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$QueryCompilationResultActionsResponse>>;
|
|
2394
3706
|
query(params: Params$Resource$Projects$Locations$Repositories$Compilationresults$Query, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2395
3707
|
query(params: Params$Resource$Projects$Locations$Repositories$Compilationresults$Query, options: MethodOptions | BodyResponseCallback<Schema$QueryCompilationResultActionsResponse>, callback: BodyResponseCallback<Schema$QueryCompilationResultActionsResponse>): void;
|
|
2396
3708
|
query(params: Params$Resource$Projects$Locations$Repositories$Compilationresults$Query, callback: BodyResponseCallback<Schema$QueryCompilationResultActionsResponse>): void;
|
|
@@ -2457,70 +3769,387 @@ export declare namespace dataform_v1beta1 {
|
|
|
2457
3769
|
constructor(context: APIRequestContext);
|
|
2458
3770
|
/**
|
|
2459
3771
|
* Creates a new ReleaseConfig in a given Repository.
|
|
3772
|
+
* @example
|
|
3773
|
+
* ```js
|
|
3774
|
+
* // Before running the sample:
|
|
3775
|
+
* // - Enable the API at:
|
|
3776
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
3777
|
+
* // - Login into gcloud by running:
|
|
3778
|
+
* // ```sh
|
|
3779
|
+
* // $ gcloud auth application-default login
|
|
3780
|
+
* // ```
|
|
3781
|
+
* // - Install the npm module by running:
|
|
3782
|
+
* // ```sh
|
|
3783
|
+
* // $ npm install googleapis
|
|
3784
|
+
* // ```
|
|
3785
|
+
*
|
|
3786
|
+
* const {google} = require('googleapis');
|
|
3787
|
+
* const dataform = google.dataform('v1beta1');
|
|
3788
|
+
*
|
|
3789
|
+
* async function main() {
|
|
3790
|
+
* const auth = new google.auth.GoogleAuth({
|
|
3791
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
3792
|
+
* scopes: [
|
|
3793
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
3794
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
3795
|
+
* ],
|
|
3796
|
+
* });
|
|
3797
|
+
*
|
|
3798
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
3799
|
+
* const authClient = await auth.getClient();
|
|
3800
|
+
* google.options({auth: authClient});
|
|
3801
|
+
*
|
|
3802
|
+
* // Do the magic
|
|
3803
|
+
* const res =
|
|
3804
|
+
* await dataform.projects.locations.repositories.releaseConfigs.create({
|
|
3805
|
+
* // Required. The repository in which to create the release config. Must be in the format `projects/x/locations/x/repositories/x`.
|
|
3806
|
+
* parent:
|
|
3807
|
+
* 'projects/my-project/locations/my-location/repositories/my-repositorie',
|
|
3808
|
+
* // Required. The ID to use for the release config, which will become the final component of the release config's resource name.
|
|
3809
|
+
* releaseConfigId: 'placeholder-value',
|
|
3810
|
+
*
|
|
3811
|
+
* // Request body metadata
|
|
3812
|
+
* requestBody: {
|
|
3813
|
+
* // request body parameters
|
|
3814
|
+
* // {
|
|
3815
|
+
* // "codeCompilationConfig": {},
|
|
3816
|
+
* // "cronSchedule": "my_cronSchedule",
|
|
3817
|
+
* // "disabled": false,
|
|
3818
|
+
* // "gitCommitish": "my_gitCommitish",
|
|
3819
|
+
* // "internalMetadata": "my_internalMetadata",
|
|
3820
|
+
* // "name": "my_name",
|
|
3821
|
+
* // "recentScheduledReleaseRecords": [],
|
|
3822
|
+
* // "releaseCompilationResult": "my_releaseCompilationResult",
|
|
3823
|
+
* // "timeZone": "my_timeZone"
|
|
3824
|
+
* // }
|
|
3825
|
+
* },
|
|
3826
|
+
* });
|
|
3827
|
+
* console.log(res.data);
|
|
3828
|
+
*
|
|
3829
|
+
* // Example response
|
|
3830
|
+
* // {
|
|
3831
|
+
* // "codeCompilationConfig": {},
|
|
3832
|
+
* // "cronSchedule": "my_cronSchedule",
|
|
3833
|
+
* // "disabled": false,
|
|
3834
|
+
* // "gitCommitish": "my_gitCommitish",
|
|
3835
|
+
* // "internalMetadata": "my_internalMetadata",
|
|
3836
|
+
* // "name": "my_name",
|
|
3837
|
+
* // "recentScheduledReleaseRecords": [],
|
|
3838
|
+
* // "releaseCompilationResult": "my_releaseCompilationResult",
|
|
3839
|
+
* // "timeZone": "my_timeZone"
|
|
3840
|
+
* // }
|
|
3841
|
+
* }
|
|
3842
|
+
*
|
|
3843
|
+
* main().catch(e => {
|
|
3844
|
+
* console.error(e);
|
|
3845
|
+
* throw e;
|
|
3846
|
+
* });
|
|
3847
|
+
*
|
|
3848
|
+
* ```
|
|
2460
3849
|
*
|
|
2461
3850
|
* @param params - Parameters for request
|
|
2462
3851
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2463
3852
|
* @param callback - Optional callback that handles the response.
|
|
2464
3853
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2465
3854
|
*/
|
|
2466
|
-
create(params: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Create, options: StreamMethodOptions):
|
|
2467
|
-
create(params?: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Create, options?: MethodOptions):
|
|
3855
|
+
create(params: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
3856
|
+
create(params?: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ReleaseConfig>>;
|
|
2468
3857
|
create(params: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2469
3858
|
create(params: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Create, options: MethodOptions | BodyResponseCallback<Schema$ReleaseConfig>, callback: BodyResponseCallback<Schema$ReleaseConfig>): void;
|
|
2470
3859
|
create(params: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Create, callback: BodyResponseCallback<Schema$ReleaseConfig>): void;
|
|
2471
3860
|
create(callback: BodyResponseCallback<Schema$ReleaseConfig>): void;
|
|
2472
3861
|
/**
|
|
2473
3862
|
* Deletes a single ReleaseConfig.
|
|
3863
|
+
* @example
|
|
3864
|
+
* ```js
|
|
3865
|
+
* // Before running the sample:
|
|
3866
|
+
* // - Enable the API at:
|
|
3867
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
3868
|
+
* // - Login into gcloud by running:
|
|
3869
|
+
* // ```sh
|
|
3870
|
+
* // $ gcloud auth application-default login
|
|
3871
|
+
* // ```
|
|
3872
|
+
* // - Install the npm module by running:
|
|
3873
|
+
* // ```sh
|
|
3874
|
+
* // $ npm install googleapis
|
|
3875
|
+
* // ```
|
|
3876
|
+
*
|
|
3877
|
+
* const {google} = require('googleapis');
|
|
3878
|
+
* const dataform = google.dataform('v1beta1');
|
|
3879
|
+
*
|
|
3880
|
+
* async function main() {
|
|
3881
|
+
* const auth = new google.auth.GoogleAuth({
|
|
3882
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
3883
|
+
* scopes: [
|
|
3884
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
3885
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
3886
|
+
* ],
|
|
3887
|
+
* });
|
|
3888
|
+
*
|
|
3889
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
3890
|
+
* const authClient = await auth.getClient();
|
|
3891
|
+
* google.options({auth: authClient});
|
|
3892
|
+
*
|
|
3893
|
+
* // Do the magic
|
|
3894
|
+
* const res =
|
|
3895
|
+
* await dataform.projects.locations.repositories.releaseConfigs.delete({
|
|
3896
|
+
* // Required. The release config's name.
|
|
3897
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie/releaseConfigs/my-releaseConfig',
|
|
3898
|
+
* });
|
|
3899
|
+
* console.log(res.data);
|
|
3900
|
+
*
|
|
3901
|
+
* // Example response
|
|
3902
|
+
* // {}
|
|
3903
|
+
* }
|
|
3904
|
+
*
|
|
3905
|
+
* main().catch(e => {
|
|
3906
|
+
* console.error(e);
|
|
3907
|
+
* throw e;
|
|
3908
|
+
* });
|
|
3909
|
+
*
|
|
3910
|
+
* ```
|
|
2474
3911
|
*
|
|
2475
3912
|
* @param params - Parameters for request
|
|
2476
3913
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2477
3914
|
* @param callback - Optional callback that handles the response.
|
|
2478
3915
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2479
3916
|
*/
|
|
2480
|
-
delete(params: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Delete, options: StreamMethodOptions):
|
|
2481
|
-
delete(params?: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Delete, options?: MethodOptions):
|
|
3917
|
+
delete(params: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
3918
|
+
delete(params?: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Empty>>;
|
|
2482
3919
|
delete(params: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2483
3920
|
delete(params: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Delete, options: MethodOptions | BodyResponseCallback<Schema$Empty>, callback: BodyResponseCallback<Schema$Empty>): void;
|
|
2484
3921
|
delete(params: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Delete, callback: BodyResponseCallback<Schema$Empty>): void;
|
|
2485
3922
|
delete(callback: BodyResponseCallback<Schema$Empty>): void;
|
|
2486
3923
|
/**
|
|
2487
3924
|
* Fetches a single ReleaseConfig.
|
|
3925
|
+
* @example
|
|
3926
|
+
* ```js
|
|
3927
|
+
* // Before running the sample:
|
|
3928
|
+
* // - Enable the API at:
|
|
3929
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
3930
|
+
* // - Login into gcloud by running:
|
|
3931
|
+
* // ```sh
|
|
3932
|
+
* // $ gcloud auth application-default login
|
|
3933
|
+
* // ```
|
|
3934
|
+
* // - Install the npm module by running:
|
|
3935
|
+
* // ```sh
|
|
3936
|
+
* // $ npm install googleapis
|
|
3937
|
+
* // ```
|
|
3938
|
+
*
|
|
3939
|
+
* const {google} = require('googleapis');
|
|
3940
|
+
* const dataform = google.dataform('v1beta1');
|
|
3941
|
+
*
|
|
3942
|
+
* async function main() {
|
|
3943
|
+
* const auth = new google.auth.GoogleAuth({
|
|
3944
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
3945
|
+
* scopes: [
|
|
3946
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
3947
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
3948
|
+
* ],
|
|
3949
|
+
* });
|
|
3950
|
+
*
|
|
3951
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
3952
|
+
* const authClient = await auth.getClient();
|
|
3953
|
+
* google.options({auth: authClient});
|
|
3954
|
+
*
|
|
3955
|
+
* // Do the magic
|
|
3956
|
+
* const res = await dataform.projects.locations.repositories.releaseConfigs.get(
|
|
3957
|
+
* {
|
|
3958
|
+
* // Required. The release config's name.
|
|
3959
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie/releaseConfigs/my-releaseConfig',
|
|
3960
|
+
* },
|
|
3961
|
+
* );
|
|
3962
|
+
* console.log(res.data);
|
|
3963
|
+
*
|
|
3964
|
+
* // Example response
|
|
3965
|
+
* // {
|
|
3966
|
+
* // "codeCompilationConfig": {},
|
|
3967
|
+
* // "cronSchedule": "my_cronSchedule",
|
|
3968
|
+
* // "disabled": false,
|
|
3969
|
+
* // "gitCommitish": "my_gitCommitish",
|
|
3970
|
+
* // "internalMetadata": "my_internalMetadata",
|
|
3971
|
+
* // "name": "my_name",
|
|
3972
|
+
* // "recentScheduledReleaseRecords": [],
|
|
3973
|
+
* // "releaseCompilationResult": "my_releaseCompilationResult",
|
|
3974
|
+
* // "timeZone": "my_timeZone"
|
|
3975
|
+
* // }
|
|
3976
|
+
* }
|
|
3977
|
+
*
|
|
3978
|
+
* main().catch(e => {
|
|
3979
|
+
* console.error(e);
|
|
3980
|
+
* throw e;
|
|
3981
|
+
* });
|
|
3982
|
+
*
|
|
3983
|
+
* ```
|
|
2488
3984
|
*
|
|
2489
3985
|
* @param params - Parameters for request
|
|
2490
3986
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2491
3987
|
* @param callback - Optional callback that handles the response.
|
|
2492
3988
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2493
3989
|
*/
|
|
2494
|
-
get(params: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Get, options: StreamMethodOptions):
|
|
2495
|
-
get(params?: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Get, options?: MethodOptions):
|
|
3990
|
+
get(params: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
3991
|
+
get(params?: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ReleaseConfig>>;
|
|
2496
3992
|
get(params: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2497
3993
|
get(params: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Get, options: MethodOptions | BodyResponseCallback<Schema$ReleaseConfig>, callback: BodyResponseCallback<Schema$ReleaseConfig>): void;
|
|
2498
3994
|
get(params: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Get, callback: BodyResponseCallback<Schema$ReleaseConfig>): void;
|
|
2499
3995
|
get(callback: BodyResponseCallback<Schema$ReleaseConfig>): void;
|
|
2500
3996
|
/**
|
|
2501
3997
|
* Lists ReleaseConfigs in a given Repository.
|
|
3998
|
+
* @example
|
|
3999
|
+
* ```js
|
|
4000
|
+
* // Before running the sample:
|
|
4001
|
+
* // - Enable the API at:
|
|
4002
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
4003
|
+
* // - Login into gcloud by running:
|
|
4004
|
+
* // ```sh
|
|
4005
|
+
* // $ gcloud auth application-default login
|
|
4006
|
+
* // ```
|
|
4007
|
+
* // - Install the npm module by running:
|
|
4008
|
+
* // ```sh
|
|
4009
|
+
* // $ npm install googleapis
|
|
4010
|
+
* // ```
|
|
4011
|
+
*
|
|
4012
|
+
* const {google} = require('googleapis');
|
|
4013
|
+
* const dataform = google.dataform('v1beta1');
|
|
4014
|
+
*
|
|
4015
|
+
* async function main() {
|
|
4016
|
+
* const auth = new google.auth.GoogleAuth({
|
|
4017
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
4018
|
+
* scopes: [
|
|
4019
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
4020
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
4021
|
+
* ],
|
|
4022
|
+
* });
|
|
4023
|
+
*
|
|
4024
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
4025
|
+
* const authClient = await auth.getClient();
|
|
4026
|
+
* google.options({auth: authClient});
|
|
4027
|
+
*
|
|
4028
|
+
* // Do the magic
|
|
4029
|
+
* const res =
|
|
4030
|
+
* await dataform.projects.locations.repositories.releaseConfigs.list({
|
|
4031
|
+
* // Optional. Maximum number of release configs to return. The server may return fewer items than requested. If unspecified, the server will pick an appropriate default.
|
|
4032
|
+
* pageSize: 'placeholder-value',
|
|
4033
|
+
* // Optional. Page token received from a previous `ListReleaseConfigs` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListReleaseConfigs`, with the exception of `page_size`, must match the call that provided the page token.
|
|
4034
|
+
* pageToken: 'placeholder-value',
|
|
4035
|
+
* // Required. The repository in which to list release configs. Must be in the format `projects/x/locations/x/repositories/x`.
|
|
4036
|
+
* parent:
|
|
4037
|
+
* 'projects/my-project/locations/my-location/repositories/my-repositorie',
|
|
4038
|
+
* });
|
|
4039
|
+
* console.log(res.data);
|
|
4040
|
+
*
|
|
4041
|
+
* // Example response
|
|
4042
|
+
* // {
|
|
4043
|
+
* // "nextPageToken": "my_nextPageToken",
|
|
4044
|
+
* // "releaseConfigs": [],
|
|
4045
|
+
* // "unreachable": []
|
|
4046
|
+
* // }
|
|
4047
|
+
* }
|
|
4048
|
+
*
|
|
4049
|
+
* main().catch(e => {
|
|
4050
|
+
* console.error(e);
|
|
4051
|
+
* throw e;
|
|
4052
|
+
* });
|
|
4053
|
+
*
|
|
4054
|
+
* ```
|
|
2502
4055
|
*
|
|
2503
4056
|
* @param params - Parameters for request
|
|
2504
4057
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2505
4058
|
* @param callback - Optional callback that handles the response.
|
|
2506
4059
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2507
4060
|
*/
|
|
2508
|
-
list(params: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$List, options: StreamMethodOptions):
|
|
2509
|
-
list(params?: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$List, options?: MethodOptions):
|
|
4061
|
+
list(params: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
4062
|
+
list(params?: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListReleaseConfigsResponse>>;
|
|
2510
4063
|
list(params: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2511
4064
|
list(params: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$List, options: MethodOptions | BodyResponseCallback<Schema$ListReleaseConfigsResponse>, callback: BodyResponseCallback<Schema$ListReleaseConfigsResponse>): void;
|
|
2512
4065
|
list(params: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$List, callback: BodyResponseCallback<Schema$ListReleaseConfigsResponse>): void;
|
|
2513
4066
|
list(callback: BodyResponseCallback<Schema$ListReleaseConfigsResponse>): void;
|
|
2514
4067
|
/**
|
|
2515
4068
|
* Updates a single ReleaseConfig. **Note:** *This method does not fully implement [AIP/134](https://google.aip.dev/134). The wildcard entry (\*) is treated as a bad request, and when the `field_mask` is omitted, the request is treated as a full update on all modifiable fields.*
|
|
4069
|
+
* @example
|
|
4070
|
+
* ```js
|
|
4071
|
+
* // Before running the sample:
|
|
4072
|
+
* // - Enable the API at:
|
|
4073
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
4074
|
+
* // - Login into gcloud by running:
|
|
4075
|
+
* // ```sh
|
|
4076
|
+
* // $ gcloud auth application-default login
|
|
4077
|
+
* // ```
|
|
4078
|
+
* // - Install the npm module by running:
|
|
4079
|
+
* // ```sh
|
|
4080
|
+
* // $ npm install googleapis
|
|
4081
|
+
* // ```
|
|
4082
|
+
*
|
|
4083
|
+
* const {google} = require('googleapis');
|
|
4084
|
+
* const dataform = google.dataform('v1beta1');
|
|
4085
|
+
*
|
|
4086
|
+
* async function main() {
|
|
4087
|
+
* const auth = new google.auth.GoogleAuth({
|
|
4088
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
4089
|
+
* scopes: [
|
|
4090
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
4091
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
4092
|
+
* ],
|
|
4093
|
+
* });
|
|
4094
|
+
*
|
|
4095
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
4096
|
+
* const authClient = await auth.getClient();
|
|
4097
|
+
* google.options({auth: authClient});
|
|
4098
|
+
*
|
|
4099
|
+
* // Do the magic
|
|
4100
|
+
* const res =
|
|
4101
|
+
* await dataform.projects.locations.repositories.releaseConfigs.patch({
|
|
4102
|
+
* // Identifier. The release config's name.
|
|
4103
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie/releaseConfigs/my-releaseConfig',
|
|
4104
|
+
* // Optional. Specifies the fields to be updated in the release config. If left unset, all fields will be updated.
|
|
4105
|
+
* updateMask: 'placeholder-value',
|
|
4106
|
+
*
|
|
4107
|
+
* // Request body metadata
|
|
4108
|
+
* requestBody: {
|
|
4109
|
+
* // request body parameters
|
|
4110
|
+
* // {
|
|
4111
|
+
* // "codeCompilationConfig": {},
|
|
4112
|
+
* // "cronSchedule": "my_cronSchedule",
|
|
4113
|
+
* // "disabled": false,
|
|
4114
|
+
* // "gitCommitish": "my_gitCommitish",
|
|
4115
|
+
* // "internalMetadata": "my_internalMetadata",
|
|
4116
|
+
* // "name": "my_name",
|
|
4117
|
+
* // "recentScheduledReleaseRecords": [],
|
|
4118
|
+
* // "releaseCompilationResult": "my_releaseCompilationResult",
|
|
4119
|
+
* // "timeZone": "my_timeZone"
|
|
4120
|
+
* // }
|
|
4121
|
+
* },
|
|
4122
|
+
* });
|
|
4123
|
+
* console.log(res.data);
|
|
4124
|
+
*
|
|
4125
|
+
* // Example response
|
|
4126
|
+
* // {
|
|
4127
|
+
* // "codeCompilationConfig": {},
|
|
4128
|
+
* // "cronSchedule": "my_cronSchedule",
|
|
4129
|
+
* // "disabled": false,
|
|
4130
|
+
* // "gitCommitish": "my_gitCommitish",
|
|
4131
|
+
* // "internalMetadata": "my_internalMetadata",
|
|
4132
|
+
* // "name": "my_name",
|
|
4133
|
+
* // "recentScheduledReleaseRecords": [],
|
|
4134
|
+
* // "releaseCompilationResult": "my_releaseCompilationResult",
|
|
4135
|
+
* // "timeZone": "my_timeZone"
|
|
4136
|
+
* // }
|
|
4137
|
+
* }
|
|
4138
|
+
*
|
|
4139
|
+
* main().catch(e => {
|
|
4140
|
+
* console.error(e);
|
|
4141
|
+
* throw e;
|
|
4142
|
+
* });
|
|
4143
|
+
*
|
|
4144
|
+
* ```
|
|
2516
4145
|
*
|
|
2517
4146
|
* @param params - Parameters for request
|
|
2518
4147
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2519
4148
|
* @param callback - Optional callback that handles the response.
|
|
2520
4149
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2521
4150
|
*/
|
|
2522
|
-
patch(params: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Patch, options: StreamMethodOptions):
|
|
2523
|
-
patch(params?: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Patch, options?: MethodOptions):
|
|
4151
|
+
patch(params: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Patch, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
4152
|
+
patch(params?: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Patch, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ReleaseConfig>>;
|
|
2524
4153
|
patch(params: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Patch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2525
4154
|
patch(params: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Patch, options: MethodOptions | BodyResponseCallback<Schema$ReleaseConfig>, callback: BodyResponseCallback<Schema$ReleaseConfig>): void;
|
|
2526
4155
|
patch(params: Params$Resource$Projects$Locations$Repositories$Releaseconfigs$Patch, callback: BodyResponseCallback<Schema$ReleaseConfig>): void;
|
|
@@ -2585,70 +4214,391 @@ export declare namespace dataform_v1beta1 {
|
|
|
2585
4214
|
constructor(context: APIRequestContext);
|
|
2586
4215
|
/**
|
|
2587
4216
|
* Creates a new WorkflowConfig in a given Repository.
|
|
4217
|
+
* @example
|
|
4218
|
+
* ```js
|
|
4219
|
+
* // Before running the sample:
|
|
4220
|
+
* // - Enable the API at:
|
|
4221
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
4222
|
+
* // - Login into gcloud by running:
|
|
4223
|
+
* // ```sh
|
|
4224
|
+
* // $ gcloud auth application-default login
|
|
4225
|
+
* // ```
|
|
4226
|
+
* // - Install the npm module by running:
|
|
4227
|
+
* // ```sh
|
|
4228
|
+
* // $ npm install googleapis
|
|
4229
|
+
* // ```
|
|
4230
|
+
*
|
|
4231
|
+
* const {google} = require('googleapis');
|
|
4232
|
+
* const dataform = google.dataform('v1beta1');
|
|
4233
|
+
*
|
|
4234
|
+
* async function main() {
|
|
4235
|
+
* const auth = new google.auth.GoogleAuth({
|
|
4236
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
4237
|
+
* scopes: [
|
|
4238
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
4239
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
4240
|
+
* ],
|
|
4241
|
+
* });
|
|
4242
|
+
*
|
|
4243
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
4244
|
+
* const authClient = await auth.getClient();
|
|
4245
|
+
* google.options({auth: authClient});
|
|
4246
|
+
*
|
|
4247
|
+
* // Do the magic
|
|
4248
|
+
* const res =
|
|
4249
|
+
* await dataform.projects.locations.repositories.workflowConfigs.create({
|
|
4250
|
+
* // Required. The repository in which to create the workflow config. Must be in the format `projects/x/locations/x/repositories/x`.
|
|
4251
|
+
* parent:
|
|
4252
|
+
* 'projects/my-project/locations/my-location/repositories/my-repositorie',
|
|
4253
|
+
* // Required. The ID to use for the workflow config, which will become the final component of the workflow config's resource name.
|
|
4254
|
+
* workflowConfigId: 'placeholder-value',
|
|
4255
|
+
*
|
|
4256
|
+
* // Request body metadata
|
|
4257
|
+
* requestBody: {
|
|
4258
|
+
* // request body parameters
|
|
4259
|
+
* // {
|
|
4260
|
+
* // "createTime": "my_createTime",
|
|
4261
|
+
* // "cronSchedule": "my_cronSchedule",
|
|
4262
|
+
* // "disabled": false,
|
|
4263
|
+
* // "internalMetadata": "my_internalMetadata",
|
|
4264
|
+
* // "invocationConfig": {},
|
|
4265
|
+
* // "name": "my_name",
|
|
4266
|
+
* // "recentScheduledExecutionRecords": [],
|
|
4267
|
+
* // "releaseConfig": "my_releaseConfig",
|
|
4268
|
+
* // "timeZone": "my_timeZone",
|
|
4269
|
+
* // "updateTime": "my_updateTime"
|
|
4270
|
+
* // }
|
|
4271
|
+
* },
|
|
4272
|
+
* });
|
|
4273
|
+
* console.log(res.data);
|
|
4274
|
+
*
|
|
4275
|
+
* // Example response
|
|
4276
|
+
* // {
|
|
4277
|
+
* // "createTime": "my_createTime",
|
|
4278
|
+
* // "cronSchedule": "my_cronSchedule",
|
|
4279
|
+
* // "disabled": false,
|
|
4280
|
+
* // "internalMetadata": "my_internalMetadata",
|
|
4281
|
+
* // "invocationConfig": {},
|
|
4282
|
+
* // "name": "my_name",
|
|
4283
|
+
* // "recentScheduledExecutionRecords": [],
|
|
4284
|
+
* // "releaseConfig": "my_releaseConfig",
|
|
4285
|
+
* // "timeZone": "my_timeZone",
|
|
4286
|
+
* // "updateTime": "my_updateTime"
|
|
4287
|
+
* // }
|
|
4288
|
+
* }
|
|
4289
|
+
*
|
|
4290
|
+
* main().catch(e => {
|
|
4291
|
+
* console.error(e);
|
|
4292
|
+
* throw e;
|
|
4293
|
+
* });
|
|
4294
|
+
*
|
|
4295
|
+
* ```
|
|
2588
4296
|
*
|
|
2589
4297
|
* @param params - Parameters for request
|
|
2590
4298
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2591
4299
|
* @param callback - Optional callback that handles the response.
|
|
2592
4300
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2593
4301
|
*/
|
|
2594
|
-
create(params: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Create, options: StreamMethodOptions):
|
|
2595
|
-
create(params?: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Create, options?: MethodOptions):
|
|
4302
|
+
create(params: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
4303
|
+
create(params?: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$WorkflowConfig>>;
|
|
2596
4304
|
create(params: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2597
4305
|
create(params: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Create, options: MethodOptions | BodyResponseCallback<Schema$WorkflowConfig>, callback: BodyResponseCallback<Schema$WorkflowConfig>): void;
|
|
2598
4306
|
create(params: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Create, callback: BodyResponseCallback<Schema$WorkflowConfig>): void;
|
|
2599
4307
|
create(callback: BodyResponseCallback<Schema$WorkflowConfig>): void;
|
|
2600
4308
|
/**
|
|
2601
4309
|
* Deletes a single WorkflowConfig.
|
|
4310
|
+
* @example
|
|
4311
|
+
* ```js
|
|
4312
|
+
* // Before running the sample:
|
|
4313
|
+
* // - Enable the API at:
|
|
4314
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
4315
|
+
* // - Login into gcloud by running:
|
|
4316
|
+
* // ```sh
|
|
4317
|
+
* // $ gcloud auth application-default login
|
|
4318
|
+
* // ```
|
|
4319
|
+
* // - Install the npm module by running:
|
|
4320
|
+
* // ```sh
|
|
4321
|
+
* // $ npm install googleapis
|
|
4322
|
+
* // ```
|
|
4323
|
+
*
|
|
4324
|
+
* const {google} = require('googleapis');
|
|
4325
|
+
* const dataform = google.dataform('v1beta1');
|
|
4326
|
+
*
|
|
4327
|
+
* async function main() {
|
|
4328
|
+
* const auth = new google.auth.GoogleAuth({
|
|
4329
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
4330
|
+
* scopes: [
|
|
4331
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
4332
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
4333
|
+
* ],
|
|
4334
|
+
* });
|
|
4335
|
+
*
|
|
4336
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
4337
|
+
* const authClient = await auth.getClient();
|
|
4338
|
+
* google.options({auth: authClient});
|
|
4339
|
+
*
|
|
4340
|
+
* // Do the magic
|
|
4341
|
+
* const res =
|
|
4342
|
+
* await dataform.projects.locations.repositories.workflowConfigs.delete({
|
|
4343
|
+
* // Required. The workflow config's name.
|
|
4344
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie/workflowConfigs/my-workflowConfig',
|
|
4345
|
+
* });
|
|
4346
|
+
* console.log(res.data);
|
|
4347
|
+
*
|
|
4348
|
+
* // Example response
|
|
4349
|
+
* // {}
|
|
4350
|
+
* }
|
|
4351
|
+
*
|
|
4352
|
+
* main().catch(e => {
|
|
4353
|
+
* console.error(e);
|
|
4354
|
+
* throw e;
|
|
4355
|
+
* });
|
|
4356
|
+
*
|
|
4357
|
+
* ```
|
|
2602
4358
|
*
|
|
2603
4359
|
* @param params - Parameters for request
|
|
2604
4360
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2605
4361
|
* @param callback - Optional callback that handles the response.
|
|
2606
4362
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2607
4363
|
*/
|
|
2608
|
-
delete(params: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Delete, options: StreamMethodOptions):
|
|
2609
|
-
delete(params?: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Delete, options?: MethodOptions):
|
|
4364
|
+
delete(params: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
4365
|
+
delete(params?: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Empty>>;
|
|
2610
4366
|
delete(params: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2611
4367
|
delete(params: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Delete, options: MethodOptions | BodyResponseCallback<Schema$Empty>, callback: BodyResponseCallback<Schema$Empty>): void;
|
|
2612
4368
|
delete(params: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Delete, callback: BodyResponseCallback<Schema$Empty>): void;
|
|
2613
4369
|
delete(callback: BodyResponseCallback<Schema$Empty>): void;
|
|
2614
4370
|
/**
|
|
2615
4371
|
* Fetches a single WorkflowConfig.
|
|
4372
|
+
* @example
|
|
4373
|
+
* ```js
|
|
4374
|
+
* // Before running the sample:
|
|
4375
|
+
* // - Enable the API at:
|
|
4376
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
4377
|
+
* // - Login into gcloud by running:
|
|
4378
|
+
* // ```sh
|
|
4379
|
+
* // $ gcloud auth application-default login
|
|
4380
|
+
* // ```
|
|
4381
|
+
* // - Install the npm module by running:
|
|
4382
|
+
* // ```sh
|
|
4383
|
+
* // $ npm install googleapis
|
|
4384
|
+
* // ```
|
|
4385
|
+
*
|
|
4386
|
+
* const {google} = require('googleapis');
|
|
4387
|
+
* const dataform = google.dataform('v1beta1');
|
|
4388
|
+
*
|
|
4389
|
+
* async function main() {
|
|
4390
|
+
* const auth = new google.auth.GoogleAuth({
|
|
4391
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
4392
|
+
* scopes: [
|
|
4393
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
4394
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
4395
|
+
* ],
|
|
4396
|
+
* });
|
|
4397
|
+
*
|
|
4398
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
4399
|
+
* const authClient = await auth.getClient();
|
|
4400
|
+
* google.options({auth: authClient});
|
|
4401
|
+
*
|
|
4402
|
+
* // Do the magic
|
|
4403
|
+
* const res =
|
|
4404
|
+
* await dataform.projects.locations.repositories.workflowConfigs.get({
|
|
4405
|
+
* // Required. The workflow config's name.
|
|
4406
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie/workflowConfigs/my-workflowConfig',
|
|
4407
|
+
* });
|
|
4408
|
+
* console.log(res.data);
|
|
4409
|
+
*
|
|
4410
|
+
* // Example response
|
|
4411
|
+
* // {
|
|
4412
|
+
* // "createTime": "my_createTime",
|
|
4413
|
+
* // "cronSchedule": "my_cronSchedule",
|
|
4414
|
+
* // "disabled": false,
|
|
4415
|
+
* // "internalMetadata": "my_internalMetadata",
|
|
4416
|
+
* // "invocationConfig": {},
|
|
4417
|
+
* // "name": "my_name",
|
|
4418
|
+
* // "recentScheduledExecutionRecords": [],
|
|
4419
|
+
* // "releaseConfig": "my_releaseConfig",
|
|
4420
|
+
* // "timeZone": "my_timeZone",
|
|
4421
|
+
* // "updateTime": "my_updateTime"
|
|
4422
|
+
* // }
|
|
4423
|
+
* }
|
|
4424
|
+
*
|
|
4425
|
+
* main().catch(e => {
|
|
4426
|
+
* console.error(e);
|
|
4427
|
+
* throw e;
|
|
4428
|
+
* });
|
|
4429
|
+
*
|
|
4430
|
+
* ```
|
|
2616
4431
|
*
|
|
2617
4432
|
* @param params - Parameters for request
|
|
2618
4433
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2619
4434
|
* @param callback - Optional callback that handles the response.
|
|
2620
4435
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2621
4436
|
*/
|
|
2622
|
-
get(params: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Get, options: StreamMethodOptions):
|
|
2623
|
-
get(params?: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Get, options?: MethodOptions):
|
|
4437
|
+
get(params: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
4438
|
+
get(params?: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$WorkflowConfig>>;
|
|
2624
4439
|
get(params: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2625
4440
|
get(params: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Get, options: MethodOptions | BodyResponseCallback<Schema$WorkflowConfig>, callback: BodyResponseCallback<Schema$WorkflowConfig>): void;
|
|
2626
4441
|
get(params: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Get, callback: BodyResponseCallback<Schema$WorkflowConfig>): void;
|
|
2627
4442
|
get(callback: BodyResponseCallback<Schema$WorkflowConfig>): void;
|
|
2628
4443
|
/**
|
|
2629
4444
|
* Lists WorkflowConfigs in a given Repository.
|
|
4445
|
+
* @example
|
|
4446
|
+
* ```js
|
|
4447
|
+
* // Before running the sample:
|
|
4448
|
+
* // - Enable the API at:
|
|
4449
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
4450
|
+
* // - Login into gcloud by running:
|
|
4451
|
+
* // ```sh
|
|
4452
|
+
* // $ gcloud auth application-default login
|
|
4453
|
+
* // ```
|
|
4454
|
+
* // - Install the npm module by running:
|
|
4455
|
+
* // ```sh
|
|
4456
|
+
* // $ npm install googleapis
|
|
4457
|
+
* // ```
|
|
4458
|
+
*
|
|
4459
|
+
* const {google} = require('googleapis');
|
|
4460
|
+
* const dataform = google.dataform('v1beta1');
|
|
4461
|
+
*
|
|
4462
|
+
* async function main() {
|
|
4463
|
+
* const auth = new google.auth.GoogleAuth({
|
|
4464
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
4465
|
+
* scopes: [
|
|
4466
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
4467
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
4468
|
+
* ],
|
|
4469
|
+
* });
|
|
4470
|
+
*
|
|
4471
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
4472
|
+
* const authClient = await auth.getClient();
|
|
4473
|
+
* google.options({auth: authClient});
|
|
4474
|
+
*
|
|
4475
|
+
* // Do the magic
|
|
4476
|
+
* const res =
|
|
4477
|
+
* await dataform.projects.locations.repositories.workflowConfigs.list({
|
|
4478
|
+
* // Optional. Maximum number of workflow configs to return. The server may return fewer items than requested. If unspecified, the server will pick an appropriate default.
|
|
4479
|
+
* pageSize: 'placeholder-value',
|
|
4480
|
+
* // Optional. Page token received from a previous `ListWorkflowConfigs` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListWorkflowConfigs`, with the exception of `page_size`, must match the call that provided the page token.
|
|
4481
|
+
* pageToken: 'placeholder-value',
|
|
4482
|
+
* // Required. The repository in which to list workflow configs. Must be in the format `projects/x/locations/x/repositories/x`.
|
|
4483
|
+
* parent:
|
|
4484
|
+
* 'projects/my-project/locations/my-location/repositories/my-repositorie',
|
|
4485
|
+
* });
|
|
4486
|
+
* console.log(res.data);
|
|
4487
|
+
*
|
|
4488
|
+
* // Example response
|
|
4489
|
+
* // {
|
|
4490
|
+
* // "nextPageToken": "my_nextPageToken",
|
|
4491
|
+
* // "unreachable": [],
|
|
4492
|
+
* // "workflowConfigs": []
|
|
4493
|
+
* // }
|
|
4494
|
+
* }
|
|
4495
|
+
*
|
|
4496
|
+
* main().catch(e => {
|
|
4497
|
+
* console.error(e);
|
|
4498
|
+
* throw e;
|
|
4499
|
+
* });
|
|
4500
|
+
*
|
|
4501
|
+
* ```
|
|
2630
4502
|
*
|
|
2631
4503
|
* @param params - Parameters for request
|
|
2632
4504
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2633
4505
|
* @param callback - Optional callback that handles the response.
|
|
2634
4506
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2635
4507
|
*/
|
|
2636
|
-
list(params: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$List, options: StreamMethodOptions):
|
|
2637
|
-
list(params?: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$List, options?: MethodOptions):
|
|
4508
|
+
list(params: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
4509
|
+
list(params?: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListWorkflowConfigsResponse>>;
|
|
2638
4510
|
list(params: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2639
4511
|
list(params: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$List, options: MethodOptions | BodyResponseCallback<Schema$ListWorkflowConfigsResponse>, callback: BodyResponseCallback<Schema$ListWorkflowConfigsResponse>): void;
|
|
2640
4512
|
list(params: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$List, callback: BodyResponseCallback<Schema$ListWorkflowConfigsResponse>): void;
|
|
2641
4513
|
list(callback: BodyResponseCallback<Schema$ListWorkflowConfigsResponse>): void;
|
|
2642
4514
|
/**
|
|
2643
4515
|
* Updates a single WorkflowConfig. **Note:** *This method does not fully implement [AIP/134](https://google.aip.dev/134). The wildcard entry (\*) is treated as a bad request, and when the `field_mask` is omitted, the request is treated as a full update on all modifiable fields.*
|
|
4516
|
+
* @example
|
|
4517
|
+
* ```js
|
|
4518
|
+
* // Before running the sample:
|
|
4519
|
+
* // - Enable the API at:
|
|
4520
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
4521
|
+
* // - Login into gcloud by running:
|
|
4522
|
+
* // ```sh
|
|
4523
|
+
* // $ gcloud auth application-default login
|
|
4524
|
+
* // ```
|
|
4525
|
+
* // - Install the npm module by running:
|
|
4526
|
+
* // ```sh
|
|
4527
|
+
* // $ npm install googleapis
|
|
4528
|
+
* // ```
|
|
4529
|
+
*
|
|
4530
|
+
* const {google} = require('googleapis');
|
|
4531
|
+
* const dataform = google.dataform('v1beta1');
|
|
4532
|
+
*
|
|
4533
|
+
* async function main() {
|
|
4534
|
+
* const auth = new google.auth.GoogleAuth({
|
|
4535
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
4536
|
+
* scopes: [
|
|
4537
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
4538
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
4539
|
+
* ],
|
|
4540
|
+
* });
|
|
4541
|
+
*
|
|
4542
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
4543
|
+
* const authClient = await auth.getClient();
|
|
4544
|
+
* google.options({auth: authClient});
|
|
4545
|
+
*
|
|
4546
|
+
* // Do the magic
|
|
4547
|
+
* const res =
|
|
4548
|
+
* await dataform.projects.locations.repositories.workflowConfigs.patch({
|
|
4549
|
+
* // Identifier. The workflow config's name.
|
|
4550
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie/workflowConfigs/my-workflowConfig',
|
|
4551
|
+
* // Optional. Specifies the fields to be updated in the workflow config. If left unset, all fields will be updated.
|
|
4552
|
+
* updateMask: 'placeholder-value',
|
|
4553
|
+
*
|
|
4554
|
+
* // Request body metadata
|
|
4555
|
+
* requestBody: {
|
|
4556
|
+
* // request body parameters
|
|
4557
|
+
* // {
|
|
4558
|
+
* // "createTime": "my_createTime",
|
|
4559
|
+
* // "cronSchedule": "my_cronSchedule",
|
|
4560
|
+
* // "disabled": false,
|
|
4561
|
+
* // "internalMetadata": "my_internalMetadata",
|
|
4562
|
+
* // "invocationConfig": {},
|
|
4563
|
+
* // "name": "my_name",
|
|
4564
|
+
* // "recentScheduledExecutionRecords": [],
|
|
4565
|
+
* // "releaseConfig": "my_releaseConfig",
|
|
4566
|
+
* // "timeZone": "my_timeZone",
|
|
4567
|
+
* // "updateTime": "my_updateTime"
|
|
4568
|
+
* // }
|
|
4569
|
+
* },
|
|
4570
|
+
* });
|
|
4571
|
+
* console.log(res.data);
|
|
4572
|
+
*
|
|
4573
|
+
* // Example response
|
|
4574
|
+
* // {
|
|
4575
|
+
* // "createTime": "my_createTime",
|
|
4576
|
+
* // "cronSchedule": "my_cronSchedule",
|
|
4577
|
+
* // "disabled": false,
|
|
4578
|
+
* // "internalMetadata": "my_internalMetadata",
|
|
4579
|
+
* // "invocationConfig": {},
|
|
4580
|
+
* // "name": "my_name",
|
|
4581
|
+
* // "recentScheduledExecutionRecords": [],
|
|
4582
|
+
* // "releaseConfig": "my_releaseConfig",
|
|
4583
|
+
* // "timeZone": "my_timeZone",
|
|
4584
|
+
* // "updateTime": "my_updateTime"
|
|
4585
|
+
* // }
|
|
4586
|
+
* }
|
|
4587
|
+
*
|
|
4588
|
+
* main().catch(e => {
|
|
4589
|
+
* console.error(e);
|
|
4590
|
+
* throw e;
|
|
4591
|
+
* });
|
|
4592
|
+
*
|
|
4593
|
+
* ```
|
|
2644
4594
|
*
|
|
2645
4595
|
* @param params - Parameters for request
|
|
2646
4596
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2647
4597
|
* @param callback - Optional callback that handles the response.
|
|
2648
4598
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2649
4599
|
*/
|
|
2650
|
-
patch(params: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Patch, options: StreamMethodOptions):
|
|
2651
|
-
patch(params?: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Patch, options?: MethodOptions):
|
|
4600
|
+
patch(params: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Patch, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
4601
|
+
patch(params?: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Patch, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$WorkflowConfig>>;
|
|
2652
4602
|
patch(params: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Patch, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2653
4603
|
patch(params: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Patch, options: MethodOptions | BodyResponseCallback<Schema$WorkflowConfig>, callback: BodyResponseCallback<Schema$WorkflowConfig>): void;
|
|
2654
4604
|
patch(params: Params$Resource$Projects$Locations$Repositories$Workflowconfigs$Patch, callback: BodyResponseCallback<Schema$WorkflowConfig>): void;
|
|
@@ -2713,84 +4663,435 @@ export declare namespace dataform_v1beta1 {
|
|
|
2713
4663
|
constructor(context: APIRequestContext);
|
|
2714
4664
|
/**
|
|
2715
4665
|
* Requests cancellation of a running WorkflowInvocation.
|
|
4666
|
+
* @example
|
|
4667
|
+
* ```js
|
|
4668
|
+
* // Before running the sample:
|
|
4669
|
+
* // - Enable the API at:
|
|
4670
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
4671
|
+
* // - Login into gcloud by running:
|
|
4672
|
+
* // ```sh
|
|
4673
|
+
* // $ gcloud auth application-default login
|
|
4674
|
+
* // ```
|
|
4675
|
+
* // - Install the npm module by running:
|
|
4676
|
+
* // ```sh
|
|
4677
|
+
* // $ npm install googleapis
|
|
4678
|
+
* // ```
|
|
4679
|
+
*
|
|
4680
|
+
* const {google} = require('googleapis');
|
|
4681
|
+
* const dataform = google.dataform('v1beta1');
|
|
4682
|
+
*
|
|
4683
|
+
* async function main() {
|
|
4684
|
+
* const auth = new google.auth.GoogleAuth({
|
|
4685
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
4686
|
+
* scopes: [
|
|
4687
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
4688
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
4689
|
+
* ],
|
|
4690
|
+
* });
|
|
4691
|
+
*
|
|
4692
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
4693
|
+
* const authClient = await auth.getClient();
|
|
4694
|
+
* google.options({auth: authClient});
|
|
4695
|
+
*
|
|
4696
|
+
* // Do the magic
|
|
4697
|
+
* const res =
|
|
4698
|
+
* await dataform.projects.locations.repositories.workflowInvocations.cancel({
|
|
4699
|
+
* // Required. The workflow invocation resource's name.
|
|
4700
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie/workflowInvocations/my-workflowInvocation',
|
|
4701
|
+
*
|
|
4702
|
+
* // Request body metadata
|
|
4703
|
+
* requestBody: {
|
|
4704
|
+
* // request body parameters
|
|
4705
|
+
* // {}
|
|
4706
|
+
* },
|
|
4707
|
+
* });
|
|
4708
|
+
* console.log(res.data);
|
|
4709
|
+
*
|
|
4710
|
+
* // Example response
|
|
4711
|
+
* // {}
|
|
4712
|
+
* }
|
|
4713
|
+
*
|
|
4714
|
+
* main().catch(e => {
|
|
4715
|
+
* console.error(e);
|
|
4716
|
+
* throw e;
|
|
4717
|
+
* });
|
|
4718
|
+
*
|
|
4719
|
+
* ```
|
|
2716
4720
|
*
|
|
2717
4721
|
* @param params - Parameters for request
|
|
2718
4722
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2719
4723
|
* @param callback - Optional callback that handles the response.
|
|
2720
4724
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2721
4725
|
*/
|
|
2722
|
-
cancel(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Cancel, options: StreamMethodOptions):
|
|
2723
|
-
cancel(params?: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Cancel, options?: MethodOptions):
|
|
4726
|
+
cancel(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Cancel, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
4727
|
+
cancel(params?: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Cancel, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$CancelWorkflowInvocationResponse>>;
|
|
2724
4728
|
cancel(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Cancel, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2725
4729
|
cancel(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Cancel, options: MethodOptions | BodyResponseCallback<Schema$CancelWorkflowInvocationResponse>, callback: BodyResponseCallback<Schema$CancelWorkflowInvocationResponse>): void;
|
|
2726
4730
|
cancel(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Cancel, callback: BodyResponseCallback<Schema$CancelWorkflowInvocationResponse>): void;
|
|
2727
4731
|
cancel(callback: BodyResponseCallback<Schema$CancelWorkflowInvocationResponse>): void;
|
|
2728
4732
|
/**
|
|
2729
4733
|
* Creates a new WorkflowInvocation in a given Repository.
|
|
4734
|
+
* @example
|
|
4735
|
+
* ```js
|
|
4736
|
+
* // Before running the sample:
|
|
4737
|
+
* // - Enable the API at:
|
|
4738
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
4739
|
+
* // - Login into gcloud by running:
|
|
4740
|
+
* // ```sh
|
|
4741
|
+
* // $ gcloud auth application-default login
|
|
4742
|
+
* // ```
|
|
4743
|
+
* // - Install the npm module by running:
|
|
4744
|
+
* // ```sh
|
|
4745
|
+
* // $ npm install googleapis
|
|
4746
|
+
* // ```
|
|
4747
|
+
*
|
|
4748
|
+
* const {google} = require('googleapis');
|
|
4749
|
+
* const dataform = google.dataform('v1beta1');
|
|
4750
|
+
*
|
|
4751
|
+
* async function main() {
|
|
4752
|
+
* const auth = new google.auth.GoogleAuth({
|
|
4753
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
4754
|
+
* scopes: [
|
|
4755
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
4756
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
4757
|
+
* ],
|
|
4758
|
+
* });
|
|
4759
|
+
*
|
|
4760
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
4761
|
+
* const authClient = await auth.getClient();
|
|
4762
|
+
* google.options({auth: authClient});
|
|
4763
|
+
*
|
|
4764
|
+
* // Do the magic
|
|
4765
|
+
* const res =
|
|
4766
|
+
* await dataform.projects.locations.repositories.workflowInvocations.create({
|
|
4767
|
+
* // Required. The repository in which to create the workflow invocation. Must be in the format `projects/x/locations/x/repositories/x`.
|
|
4768
|
+
* parent:
|
|
4769
|
+
* 'projects/my-project/locations/my-location/repositories/my-repositorie',
|
|
4770
|
+
*
|
|
4771
|
+
* // Request body metadata
|
|
4772
|
+
* requestBody: {
|
|
4773
|
+
* // request body parameters
|
|
4774
|
+
* // {
|
|
4775
|
+
* // "compilationResult": "my_compilationResult",
|
|
4776
|
+
* // "dataEncryptionState": {},
|
|
4777
|
+
* // "internalMetadata": "my_internalMetadata",
|
|
4778
|
+
* // "invocationConfig": {},
|
|
4779
|
+
* // "invocationTiming": {},
|
|
4780
|
+
* // "name": "my_name",
|
|
4781
|
+
* // "resolvedCompilationResult": "my_resolvedCompilationResult",
|
|
4782
|
+
* // "state": "my_state",
|
|
4783
|
+
* // "workflowConfig": "my_workflowConfig"
|
|
4784
|
+
* // }
|
|
4785
|
+
* },
|
|
4786
|
+
* });
|
|
4787
|
+
* console.log(res.data);
|
|
4788
|
+
*
|
|
4789
|
+
* // Example response
|
|
4790
|
+
* // {
|
|
4791
|
+
* // "compilationResult": "my_compilationResult",
|
|
4792
|
+
* // "dataEncryptionState": {},
|
|
4793
|
+
* // "internalMetadata": "my_internalMetadata",
|
|
4794
|
+
* // "invocationConfig": {},
|
|
4795
|
+
* // "invocationTiming": {},
|
|
4796
|
+
* // "name": "my_name",
|
|
4797
|
+
* // "resolvedCompilationResult": "my_resolvedCompilationResult",
|
|
4798
|
+
* // "state": "my_state",
|
|
4799
|
+
* // "workflowConfig": "my_workflowConfig"
|
|
4800
|
+
* // }
|
|
4801
|
+
* }
|
|
4802
|
+
*
|
|
4803
|
+
* main().catch(e => {
|
|
4804
|
+
* console.error(e);
|
|
4805
|
+
* throw e;
|
|
4806
|
+
* });
|
|
4807
|
+
*
|
|
4808
|
+
* ```
|
|
2730
4809
|
*
|
|
2731
4810
|
* @param params - Parameters for request
|
|
2732
4811
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2733
4812
|
* @param callback - Optional callback that handles the response.
|
|
2734
4813
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2735
4814
|
*/
|
|
2736
|
-
create(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Create, options: StreamMethodOptions):
|
|
2737
|
-
create(params?: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Create, options?: MethodOptions):
|
|
4815
|
+
create(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
4816
|
+
create(params?: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$WorkflowInvocation>>;
|
|
2738
4817
|
create(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2739
4818
|
create(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Create, options: MethodOptions | BodyResponseCallback<Schema$WorkflowInvocation>, callback: BodyResponseCallback<Schema$WorkflowInvocation>): void;
|
|
2740
4819
|
create(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Create, callback: BodyResponseCallback<Schema$WorkflowInvocation>): void;
|
|
2741
4820
|
create(callback: BodyResponseCallback<Schema$WorkflowInvocation>): void;
|
|
2742
4821
|
/**
|
|
2743
4822
|
* Deletes a single WorkflowInvocation.
|
|
4823
|
+
* @example
|
|
4824
|
+
* ```js
|
|
4825
|
+
* // Before running the sample:
|
|
4826
|
+
* // - Enable the API at:
|
|
4827
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
4828
|
+
* // - Login into gcloud by running:
|
|
4829
|
+
* // ```sh
|
|
4830
|
+
* // $ gcloud auth application-default login
|
|
4831
|
+
* // ```
|
|
4832
|
+
* // - Install the npm module by running:
|
|
4833
|
+
* // ```sh
|
|
4834
|
+
* // $ npm install googleapis
|
|
4835
|
+
* // ```
|
|
4836
|
+
*
|
|
4837
|
+
* const {google} = require('googleapis');
|
|
4838
|
+
* const dataform = google.dataform('v1beta1');
|
|
4839
|
+
*
|
|
4840
|
+
* async function main() {
|
|
4841
|
+
* const auth = new google.auth.GoogleAuth({
|
|
4842
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
4843
|
+
* scopes: [
|
|
4844
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
4845
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
4846
|
+
* ],
|
|
4847
|
+
* });
|
|
4848
|
+
*
|
|
4849
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
4850
|
+
* const authClient = await auth.getClient();
|
|
4851
|
+
* google.options({auth: authClient});
|
|
4852
|
+
*
|
|
4853
|
+
* // Do the magic
|
|
4854
|
+
* const res =
|
|
4855
|
+
* await dataform.projects.locations.repositories.workflowInvocations.delete({
|
|
4856
|
+
* // Required. The workflow invocation resource's name.
|
|
4857
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie/workflowInvocations/my-workflowInvocation',
|
|
4858
|
+
* });
|
|
4859
|
+
* console.log(res.data);
|
|
4860
|
+
*
|
|
4861
|
+
* // Example response
|
|
4862
|
+
* // {}
|
|
4863
|
+
* }
|
|
4864
|
+
*
|
|
4865
|
+
* main().catch(e => {
|
|
4866
|
+
* console.error(e);
|
|
4867
|
+
* throw e;
|
|
4868
|
+
* });
|
|
4869
|
+
*
|
|
4870
|
+
* ```
|
|
2744
4871
|
*
|
|
2745
4872
|
* @param params - Parameters for request
|
|
2746
4873
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2747
4874
|
* @param callback - Optional callback that handles the response.
|
|
2748
4875
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2749
4876
|
*/
|
|
2750
|
-
delete(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Delete, options: StreamMethodOptions):
|
|
2751
|
-
delete(params?: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Delete, options?: MethodOptions):
|
|
4877
|
+
delete(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
4878
|
+
delete(params?: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Empty>>;
|
|
2752
4879
|
delete(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2753
4880
|
delete(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Delete, options: MethodOptions | BodyResponseCallback<Schema$Empty>, callback: BodyResponseCallback<Schema$Empty>): void;
|
|
2754
4881
|
delete(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Delete, callback: BodyResponseCallback<Schema$Empty>): void;
|
|
2755
4882
|
delete(callback: BodyResponseCallback<Schema$Empty>): void;
|
|
2756
4883
|
/**
|
|
2757
4884
|
* Fetches a single WorkflowInvocation.
|
|
4885
|
+
* @example
|
|
4886
|
+
* ```js
|
|
4887
|
+
* // Before running the sample:
|
|
4888
|
+
* // - Enable the API at:
|
|
4889
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
4890
|
+
* // - Login into gcloud by running:
|
|
4891
|
+
* // ```sh
|
|
4892
|
+
* // $ gcloud auth application-default login
|
|
4893
|
+
* // ```
|
|
4894
|
+
* // - Install the npm module by running:
|
|
4895
|
+
* // ```sh
|
|
4896
|
+
* // $ npm install googleapis
|
|
4897
|
+
* // ```
|
|
4898
|
+
*
|
|
4899
|
+
* const {google} = require('googleapis');
|
|
4900
|
+
* const dataform = google.dataform('v1beta1');
|
|
4901
|
+
*
|
|
4902
|
+
* async function main() {
|
|
4903
|
+
* const auth = new google.auth.GoogleAuth({
|
|
4904
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
4905
|
+
* scopes: [
|
|
4906
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
4907
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
4908
|
+
* ],
|
|
4909
|
+
* });
|
|
4910
|
+
*
|
|
4911
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
4912
|
+
* const authClient = await auth.getClient();
|
|
4913
|
+
* google.options({auth: authClient});
|
|
4914
|
+
*
|
|
4915
|
+
* // Do the magic
|
|
4916
|
+
* const res =
|
|
4917
|
+
* await dataform.projects.locations.repositories.workflowInvocations.get({
|
|
4918
|
+
* // Required. The workflow invocation resource's name.
|
|
4919
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie/workflowInvocations/my-workflowInvocation',
|
|
4920
|
+
* });
|
|
4921
|
+
* console.log(res.data);
|
|
4922
|
+
*
|
|
4923
|
+
* // Example response
|
|
4924
|
+
* // {
|
|
4925
|
+
* // "compilationResult": "my_compilationResult",
|
|
4926
|
+
* // "dataEncryptionState": {},
|
|
4927
|
+
* // "internalMetadata": "my_internalMetadata",
|
|
4928
|
+
* // "invocationConfig": {},
|
|
4929
|
+
* // "invocationTiming": {},
|
|
4930
|
+
* // "name": "my_name",
|
|
4931
|
+
* // "resolvedCompilationResult": "my_resolvedCompilationResult",
|
|
4932
|
+
* // "state": "my_state",
|
|
4933
|
+
* // "workflowConfig": "my_workflowConfig"
|
|
4934
|
+
* // }
|
|
4935
|
+
* }
|
|
4936
|
+
*
|
|
4937
|
+
* main().catch(e => {
|
|
4938
|
+
* console.error(e);
|
|
4939
|
+
* throw e;
|
|
4940
|
+
* });
|
|
4941
|
+
*
|
|
4942
|
+
* ```
|
|
2758
4943
|
*
|
|
2759
4944
|
* @param params - Parameters for request
|
|
2760
4945
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2761
4946
|
* @param callback - Optional callback that handles the response.
|
|
2762
4947
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2763
4948
|
*/
|
|
2764
|
-
get(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Get, options: StreamMethodOptions):
|
|
2765
|
-
get(params?: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Get, options?: MethodOptions):
|
|
4949
|
+
get(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
4950
|
+
get(params?: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$WorkflowInvocation>>;
|
|
2766
4951
|
get(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2767
4952
|
get(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Get, options: MethodOptions | BodyResponseCallback<Schema$WorkflowInvocation>, callback: BodyResponseCallback<Schema$WorkflowInvocation>): void;
|
|
2768
4953
|
get(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Get, callback: BodyResponseCallback<Schema$WorkflowInvocation>): void;
|
|
2769
4954
|
get(callback: BodyResponseCallback<Schema$WorkflowInvocation>): void;
|
|
2770
4955
|
/**
|
|
2771
4956
|
* Lists WorkflowInvocations in a given Repository.
|
|
4957
|
+
* @example
|
|
4958
|
+
* ```js
|
|
4959
|
+
* // Before running the sample:
|
|
4960
|
+
* // - Enable the API at:
|
|
4961
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
4962
|
+
* // - Login into gcloud by running:
|
|
4963
|
+
* // ```sh
|
|
4964
|
+
* // $ gcloud auth application-default login
|
|
4965
|
+
* // ```
|
|
4966
|
+
* // - Install the npm module by running:
|
|
4967
|
+
* // ```sh
|
|
4968
|
+
* // $ npm install googleapis
|
|
4969
|
+
* // ```
|
|
4970
|
+
*
|
|
4971
|
+
* const {google} = require('googleapis');
|
|
4972
|
+
* const dataform = google.dataform('v1beta1');
|
|
4973
|
+
*
|
|
4974
|
+
* async function main() {
|
|
4975
|
+
* const auth = new google.auth.GoogleAuth({
|
|
4976
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
4977
|
+
* scopes: [
|
|
4978
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
4979
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
4980
|
+
* ],
|
|
4981
|
+
* });
|
|
4982
|
+
*
|
|
4983
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
4984
|
+
* const authClient = await auth.getClient();
|
|
4985
|
+
* google.options({auth: authClient});
|
|
4986
|
+
*
|
|
4987
|
+
* // Do the magic
|
|
4988
|
+
* const res =
|
|
4989
|
+
* await dataform.projects.locations.repositories.workflowInvocations.list({
|
|
4990
|
+
* // Optional. Filter for the returned list.
|
|
4991
|
+
* filter: 'placeholder-value',
|
|
4992
|
+
* // Optional. This field only supports ordering by `name`. If unspecified, the server will choose the ordering. If specified, the default order is ascending for the `name` field.
|
|
4993
|
+
* orderBy: 'placeholder-value',
|
|
4994
|
+
* // Optional. Maximum number of workflow invocations to return. The server may return fewer items than requested. If unspecified, the server will pick an appropriate default.
|
|
4995
|
+
* pageSize: 'placeholder-value',
|
|
4996
|
+
* // Optional. Page token received from a previous `ListWorkflowInvocations` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListWorkflowInvocations`, with the exception of `page_size`, must match the call that provided the page token.
|
|
4997
|
+
* pageToken: 'placeholder-value',
|
|
4998
|
+
* // Required. The parent resource of the WorkflowInvocation type. Must be in the format `projects/x/locations/x/repositories/x`.
|
|
4999
|
+
* parent:
|
|
5000
|
+
* 'projects/my-project/locations/my-location/repositories/my-repositorie',
|
|
5001
|
+
* });
|
|
5002
|
+
* console.log(res.data);
|
|
5003
|
+
*
|
|
5004
|
+
* // Example response
|
|
5005
|
+
* // {
|
|
5006
|
+
* // "nextPageToken": "my_nextPageToken",
|
|
5007
|
+
* // "unreachable": [],
|
|
5008
|
+
* // "workflowInvocations": []
|
|
5009
|
+
* // }
|
|
5010
|
+
* }
|
|
5011
|
+
*
|
|
5012
|
+
* main().catch(e => {
|
|
5013
|
+
* console.error(e);
|
|
5014
|
+
* throw e;
|
|
5015
|
+
* });
|
|
5016
|
+
*
|
|
5017
|
+
* ```
|
|
2772
5018
|
*
|
|
2773
5019
|
* @param params - Parameters for request
|
|
2774
5020
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2775
5021
|
* @param callback - Optional callback that handles the response.
|
|
2776
5022
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2777
5023
|
*/
|
|
2778
|
-
list(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$List, options: StreamMethodOptions):
|
|
2779
|
-
list(params?: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$List, options?: MethodOptions):
|
|
5024
|
+
list(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
5025
|
+
list(params?: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListWorkflowInvocationsResponse>>;
|
|
2780
5026
|
list(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2781
5027
|
list(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$List, options: MethodOptions | BodyResponseCallback<Schema$ListWorkflowInvocationsResponse>, callback: BodyResponseCallback<Schema$ListWorkflowInvocationsResponse>): void;
|
|
2782
5028
|
list(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$List, callback: BodyResponseCallback<Schema$ListWorkflowInvocationsResponse>): void;
|
|
2783
5029
|
list(callback: BodyResponseCallback<Schema$ListWorkflowInvocationsResponse>): void;
|
|
2784
5030
|
/**
|
|
2785
5031
|
* Returns WorkflowInvocationActions in a given WorkflowInvocation.
|
|
5032
|
+
* @example
|
|
5033
|
+
* ```js
|
|
5034
|
+
* // Before running the sample:
|
|
5035
|
+
* // - Enable the API at:
|
|
5036
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
5037
|
+
* // - Login into gcloud by running:
|
|
5038
|
+
* // ```sh
|
|
5039
|
+
* // $ gcloud auth application-default login
|
|
5040
|
+
* // ```
|
|
5041
|
+
* // - Install the npm module by running:
|
|
5042
|
+
* // ```sh
|
|
5043
|
+
* // $ npm install googleapis
|
|
5044
|
+
* // ```
|
|
5045
|
+
*
|
|
5046
|
+
* const {google} = require('googleapis');
|
|
5047
|
+
* const dataform = google.dataform('v1beta1');
|
|
5048
|
+
*
|
|
5049
|
+
* async function main() {
|
|
5050
|
+
* const auth = new google.auth.GoogleAuth({
|
|
5051
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
5052
|
+
* scopes: [
|
|
5053
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
5054
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
5055
|
+
* ],
|
|
5056
|
+
* });
|
|
5057
|
+
*
|
|
5058
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
5059
|
+
* const authClient = await auth.getClient();
|
|
5060
|
+
* google.options({auth: authClient});
|
|
5061
|
+
*
|
|
5062
|
+
* // Do the magic
|
|
5063
|
+
* const res =
|
|
5064
|
+
* await dataform.projects.locations.repositories.workflowInvocations.query({
|
|
5065
|
+
* // Required. The workflow invocation's name.
|
|
5066
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie/workflowInvocations/my-workflowInvocation',
|
|
5067
|
+
* // Optional. Maximum number of workflow invocations to return. The server may return fewer items than requested. If unspecified, the server will pick an appropriate default.
|
|
5068
|
+
* pageSize: 'placeholder-value',
|
|
5069
|
+
* // Optional. Page token received from a previous `QueryWorkflowInvocationActions` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `QueryWorkflowInvocationActions`, with the exception of `page_size`, must match the call that provided the page token.
|
|
5070
|
+
* pageToken: 'placeholder-value',
|
|
5071
|
+
* });
|
|
5072
|
+
* console.log(res.data);
|
|
5073
|
+
*
|
|
5074
|
+
* // Example response
|
|
5075
|
+
* // {
|
|
5076
|
+
* // "nextPageToken": "my_nextPageToken",
|
|
5077
|
+
* // "workflowInvocationActions": []
|
|
5078
|
+
* // }
|
|
5079
|
+
* }
|
|
5080
|
+
*
|
|
5081
|
+
* main().catch(e => {
|
|
5082
|
+
* console.error(e);
|
|
5083
|
+
* throw e;
|
|
5084
|
+
* });
|
|
5085
|
+
*
|
|
5086
|
+
* ```
|
|
2786
5087
|
*
|
|
2787
5088
|
* @param params - Parameters for request
|
|
2788
5089
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2789
5090
|
* @param callback - Optional callback that handles the response.
|
|
2790
5091
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2791
5092
|
*/
|
|
2792
|
-
query(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Query, options: StreamMethodOptions):
|
|
2793
|
-
query(params?: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Query, options?: MethodOptions):
|
|
5093
|
+
query(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Query, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
5094
|
+
query(params?: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Query, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$QueryWorkflowInvocationActionsResponse>>;
|
|
2794
5095
|
query(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Query, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2795
5096
|
query(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Query, options: MethodOptions | BodyResponseCallback<Schema$QueryWorkflowInvocationActionsResponse>, callback: BodyResponseCallback<Schema$QueryWorkflowInvocationActionsResponse>): void;
|
|
2796
5097
|
query(params: Params$Resource$Projects$Locations$Repositories$Workflowinvocations$Query, callback: BodyResponseCallback<Schema$QueryWorkflowInvocationActionsResponse>): void;
|
|
@@ -2869,336 +5170,1697 @@ export declare namespace dataform_v1beta1 {
|
|
|
2869
5170
|
constructor(context: APIRequestContext);
|
|
2870
5171
|
/**
|
|
2871
5172
|
* Applies a Git commit for uncommitted files in a Workspace.
|
|
5173
|
+
* @example
|
|
5174
|
+
* ```js
|
|
5175
|
+
* // Before running the sample:
|
|
5176
|
+
* // - Enable the API at:
|
|
5177
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
5178
|
+
* // - Login into gcloud by running:
|
|
5179
|
+
* // ```sh
|
|
5180
|
+
* // $ gcloud auth application-default login
|
|
5181
|
+
* // ```
|
|
5182
|
+
* // - Install the npm module by running:
|
|
5183
|
+
* // ```sh
|
|
5184
|
+
* // $ npm install googleapis
|
|
5185
|
+
* // ```
|
|
5186
|
+
*
|
|
5187
|
+
* const {google} = require('googleapis');
|
|
5188
|
+
* const dataform = google.dataform('v1beta1');
|
|
5189
|
+
*
|
|
5190
|
+
* async function main() {
|
|
5191
|
+
* const auth = new google.auth.GoogleAuth({
|
|
5192
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
5193
|
+
* scopes: [
|
|
5194
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
5195
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
5196
|
+
* ],
|
|
5197
|
+
* });
|
|
5198
|
+
*
|
|
5199
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
5200
|
+
* const authClient = await auth.getClient();
|
|
5201
|
+
* google.options({auth: authClient});
|
|
5202
|
+
*
|
|
5203
|
+
* // Do the magic
|
|
5204
|
+
* const res = await dataform.projects.locations.repositories.workspaces.commit({
|
|
5205
|
+
* // Required. The workspace's name.
|
|
5206
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie/workspaces/my-workspace',
|
|
5207
|
+
*
|
|
5208
|
+
* // Request body metadata
|
|
5209
|
+
* requestBody: {
|
|
5210
|
+
* // request body parameters
|
|
5211
|
+
* // {
|
|
5212
|
+
* // "author": {},
|
|
5213
|
+
* // "commitMessage": "my_commitMessage",
|
|
5214
|
+
* // "paths": []
|
|
5215
|
+
* // }
|
|
5216
|
+
* },
|
|
5217
|
+
* });
|
|
5218
|
+
* console.log(res.data);
|
|
5219
|
+
*
|
|
5220
|
+
* // Example response
|
|
5221
|
+
* // {}
|
|
5222
|
+
* }
|
|
5223
|
+
*
|
|
5224
|
+
* main().catch(e => {
|
|
5225
|
+
* console.error(e);
|
|
5226
|
+
* throw e;
|
|
5227
|
+
* });
|
|
5228
|
+
*
|
|
5229
|
+
* ```
|
|
2872
5230
|
*
|
|
2873
5231
|
* @param params - Parameters for request
|
|
2874
5232
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2875
5233
|
* @param callback - Optional callback that handles the response.
|
|
2876
5234
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2877
5235
|
*/
|
|
2878
|
-
commit(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Commit, options: StreamMethodOptions):
|
|
2879
|
-
commit(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Commit, options?: MethodOptions):
|
|
5236
|
+
commit(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Commit, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
5237
|
+
commit(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Commit, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$CommitWorkspaceChangesResponse>>;
|
|
2880
5238
|
commit(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Commit, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2881
5239
|
commit(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Commit, options: MethodOptions | BodyResponseCallback<Schema$CommitWorkspaceChangesResponse>, callback: BodyResponseCallback<Schema$CommitWorkspaceChangesResponse>): void;
|
|
2882
5240
|
commit(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Commit, callback: BodyResponseCallback<Schema$CommitWorkspaceChangesResponse>): void;
|
|
2883
5241
|
commit(callback: BodyResponseCallback<Schema$CommitWorkspaceChangesResponse>): void;
|
|
2884
5242
|
/**
|
|
2885
5243
|
* Creates a new Workspace in a given Repository.
|
|
5244
|
+
* @example
|
|
5245
|
+
* ```js
|
|
5246
|
+
* // Before running the sample:
|
|
5247
|
+
* // - Enable the API at:
|
|
5248
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
5249
|
+
* // - Login into gcloud by running:
|
|
5250
|
+
* // ```sh
|
|
5251
|
+
* // $ gcloud auth application-default login
|
|
5252
|
+
* // ```
|
|
5253
|
+
* // - Install the npm module by running:
|
|
5254
|
+
* // ```sh
|
|
5255
|
+
* // $ npm install googleapis
|
|
5256
|
+
* // ```
|
|
5257
|
+
*
|
|
5258
|
+
* const {google} = require('googleapis');
|
|
5259
|
+
* const dataform = google.dataform('v1beta1');
|
|
5260
|
+
*
|
|
5261
|
+
* async function main() {
|
|
5262
|
+
* const auth = new google.auth.GoogleAuth({
|
|
5263
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
5264
|
+
* scopes: [
|
|
5265
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
5266
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
5267
|
+
* ],
|
|
5268
|
+
* });
|
|
5269
|
+
*
|
|
5270
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
5271
|
+
* const authClient = await auth.getClient();
|
|
5272
|
+
* google.options({auth: authClient});
|
|
5273
|
+
*
|
|
5274
|
+
* // Do the magic
|
|
5275
|
+
* const res = await dataform.projects.locations.repositories.workspaces.create({
|
|
5276
|
+
* // Required. The repository in which to create the workspace. Must be in the format `projects/x/locations/x/repositories/x`.
|
|
5277
|
+
* parent:
|
|
5278
|
+
* 'projects/my-project/locations/my-location/repositories/my-repositorie',
|
|
5279
|
+
* // Required. The ID to use for the workspace, which will become the final component of the workspace's resource name.
|
|
5280
|
+
* workspaceId: 'placeholder-value',
|
|
5281
|
+
*
|
|
5282
|
+
* // Request body metadata
|
|
5283
|
+
* requestBody: {
|
|
5284
|
+
* // request body parameters
|
|
5285
|
+
* // {
|
|
5286
|
+
* // "createTime": "my_createTime",
|
|
5287
|
+
* // "dataEncryptionState": {},
|
|
5288
|
+
* // "internalMetadata": "my_internalMetadata",
|
|
5289
|
+
* // "name": "my_name"
|
|
5290
|
+
* // }
|
|
5291
|
+
* },
|
|
5292
|
+
* });
|
|
5293
|
+
* console.log(res.data);
|
|
5294
|
+
*
|
|
5295
|
+
* // Example response
|
|
5296
|
+
* // {
|
|
5297
|
+
* // "createTime": "my_createTime",
|
|
5298
|
+
* // "dataEncryptionState": {},
|
|
5299
|
+
* // "internalMetadata": "my_internalMetadata",
|
|
5300
|
+
* // "name": "my_name"
|
|
5301
|
+
* // }
|
|
5302
|
+
* }
|
|
5303
|
+
*
|
|
5304
|
+
* main().catch(e => {
|
|
5305
|
+
* console.error(e);
|
|
5306
|
+
* throw e;
|
|
5307
|
+
* });
|
|
5308
|
+
*
|
|
5309
|
+
* ```
|
|
2886
5310
|
*
|
|
2887
5311
|
* @param params - Parameters for request
|
|
2888
5312
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2889
5313
|
* @param callback - Optional callback that handles the response.
|
|
2890
5314
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2891
5315
|
*/
|
|
2892
|
-
create(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Create, options: StreamMethodOptions):
|
|
2893
|
-
create(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Create, options?: MethodOptions):
|
|
5316
|
+
create(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Create, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
5317
|
+
create(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Create, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Workspace>>;
|
|
2894
5318
|
create(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Create, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2895
5319
|
create(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Create, options: MethodOptions | BodyResponseCallback<Schema$Workspace>, callback: BodyResponseCallback<Schema$Workspace>): void;
|
|
2896
5320
|
create(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Create, callback: BodyResponseCallback<Schema$Workspace>): void;
|
|
2897
5321
|
create(callback: BodyResponseCallback<Schema$Workspace>): void;
|
|
2898
5322
|
/**
|
|
2899
5323
|
* Deletes a single Workspace.
|
|
5324
|
+
* @example
|
|
5325
|
+
* ```js
|
|
5326
|
+
* // Before running the sample:
|
|
5327
|
+
* // - Enable the API at:
|
|
5328
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
5329
|
+
* // - Login into gcloud by running:
|
|
5330
|
+
* // ```sh
|
|
5331
|
+
* // $ gcloud auth application-default login
|
|
5332
|
+
* // ```
|
|
5333
|
+
* // - Install the npm module by running:
|
|
5334
|
+
* // ```sh
|
|
5335
|
+
* // $ npm install googleapis
|
|
5336
|
+
* // ```
|
|
5337
|
+
*
|
|
5338
|
+
* const {google} = require('googleapis');
|
|
5339
|
+
* const dataform = google.dataform('v1beta1');
|
|
5340
|
+
*
|
|
5341
|
+
* async function main() {
|
|
5342
|
+
* const auth = new google.auth.GoogleAuth({
|
|
5343
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
5344
|
+
* scopes: [
|
|
5345
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
5346
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
5347
|
+
* ],
|
|
5348
|
+
* });
|
|
5349
|
+
*
|
|
5350
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
5351
|
+
* const authClient = await auth.getClient();
|
|
5352
|
+
* google.options({auth: authClient});
|
|
5353
|
+
*
|
|
5354
|
+
* // Do the magic
|
|
5355
|
+
* const res = await dataform.projects.locations.repositories.workspaces.delete({
|
|
5356
|
+
* // Required. The workspace resource's name.
|
|
5357
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie/workspaces/my-workspace',
|
|
5358
|
+
* });
|
|
5359
|
+
* console.log(res.data);
|
|
5360
|
+
*
|
|
5361
|
+
* // Example response
|
|
5362
|
+
* // {}
|
|
5363
|
+
* }
|
|
5364
|
+
*
|
|
5365
|
+
* main().catch(e => {
|
|
5366
|
+
* console.error(e);
|
|
5367
|
+
* throw e;
|
|
5368
|
+
* });
|
|
5369
|
+
*
|
|
5370
|
+
* ```
|
|
2900
5371
|
*
|
|
2901
5372
|
* @param params - Parameters for request
|
|
2902
5373
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2903
5374
|
* @param callback - Optional callback that handles the response.
|
|
2904
5375
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2905
5376
|
*/
|
|
2906
|
-
delete(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Delete, options: StreamMethodOptions):
|
|
2907
|
-
delete(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Delete, options?: MethodOptions):
|
|
5377
|
+
delete(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Delete, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
5378
|
+
delete(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Delete, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Empty>>;
|
|
2908
5379
|
delete(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Delete, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2909
5380
|
delete(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Delete, options: MethodOptions | BodyResponseCallback<Schema$Empty>, callback: BodyResponseCallback<Schema$Empty>): void;
|
|
2910
5381
|
delete(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Delete, callback: BodyResponseCallback<Schema$Empty>): void;
|
|
2911
5382
|
delete(callback: BodyResponseCallback<Schema$Empty>): void;
|
|
2912
5383
|
/**
|
|
2913
5384
|
* Fetches Git diff for an uncommitted file in a Workspace.
|
|
5385
|
+
* @example
|
|
5386
|
+
* ```js
|
|
5387
|
+
* // Before running the sample:
|
|
5388
|
+
* // - Enable the API at:
|
|
5389
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
5390
|
+
* // - Login into gcloud by running:
|
|
5391
|
+
* // ```sh
|
|
5392
|
+
* // $ gcloud auth application-default login
|
|
5393
|
+
* // ```
|
|
5394
|
+
* // - Install the npm module by running:
|
|
5395
|
+
* // ```sh
|
|
5396
|
+
* // $ npm install googleapis
|
|
5397
|
+
* // ```
|
|
5398
|
+
*
|
|
5399
|
+
* const {google} = require('googleapis');
|
|
5400
|
+
* const dataform = google.dataform('v1beta1');
|
|
5401
|
+
*
|
|
5402
|
+
* async function main() {
|
|
5403
|
+
* const auth = new google.auth.GoogleAuth({
|
|
5404
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
5405
|
+
* scopes: [
|
|
5406
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
5407
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
5408
|
+
* ],
|
|
5409
|
+
* });
|
|
5410
|
+
*
|
|
5411
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
5412
|
+
* const authClient = await auth.getClient();
|
|
5413
|
+
* google.options({auth: authClient});
|
|
5414
|
+
*
|
|
5415
|
+
* // Do the magic
|
|
5416
|
+
* const res =
|
|
5417
|
+
* await dataform.projects.locations.repositories.workspaces.fetchFileDiff({
|
|
5418
|
+
* // Required. The file's full path including filename, relative to the workspace root.
|
|
5419
|
+
* path: 'placeholder-value',
|
|
5420
|
+
* // Required. The workspace's name.
|
|
5421
|
+
* workspace:
|
|
5422
|
+
* 'projects/my-project/locations/my-location/repositories/my-repositorie/workspaces/my-workspace',
|
|
5423
|
+
* });
|
|
5424
|
+
* console.log(res.data);
|
|
5425
|
+
*
|
|
5426
|
+
* // Example response
|
|
5427
|
+
* // {
|
|
5428
|
+
* // "formattedDiff": "my_formattedDiff"
|
|
5429
|
+
* // }
|
|
5430
|
+
* }
|
|
5431
|
+
*
|
|
5432
|
+
* main().catch(e => {
|
|
5433
|
+
* console.error(e);
|
|
5434
|
+
* throw e;
|
|
5435
|
+
* });
|
|
5436
|
+
*
|
|
5437
|
+
* ```
|
|
2914
5438
|
*
|
|
2915
5439
|
* @param params - Parameters for request
|
|
2916
5440
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2917
5441
|
* @param callback - Optional callback that handles the response.
|
|
2918
5442
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2919
5443
|
*/
|
|
2920
|
-
fetchFileDiff(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Fetchfilediff, options: StreamMethodOptions):
|
|
2921
|
-
fetchFileDiff(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Fetchfilediff, options?: MethodOptions):
|
|
5444
|
+
fetchFileDiff(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Fetchfilediff, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
5445
|
+
fetchFileDiff(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Fetchfilediff, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$FetchFileDiffResponse>>;
|
|
2922
5446
|
fetchFileDiff(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Fetchfilediff, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2923
5447
|
fetchFileDiff(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Fetchfilediff, options: MethodOptions | BodyResponseCallback<Schema$FetchFileDiffResponse>, callback: BodyResponseCallback<Schema$FetchFileDiffResponse>): void;
|
|
2924
5448
|
fetchFileDiff(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Fetchfilediff, callback: BodyResponseCallback<Schema$FetchFileDiffResponse>): void;
|
|
2925
5449
|
fetchFileDiff(callback: BodyResponseCallback<Schema$FetchFileDiffResponse>): void;
|
|
2926
5450
|
/**
|
|
2927
5451
|
* Fetches Git statuses for the files in a Workspace.
|
|
5452
|
+
* @example
|
|
5453
|
+
* ```js
|
|
5454
|
+
* // Before running the sample:
|
|
5455
|
+
* // - Enable the API at:
|
|
5456
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
5457
|
+
* // - Login into gcloud by running:
|
|
5458
|
+
* // ```sh
|
|
5459
|
+
* // $ gcloud auth application-default login
|
|
5460
|
+
* // ```
|
|
5461
|
+
* // - Install the npm module by running:
|
|
5462
|
+
* // ```sh
|
|
5463
|
+
* // $ npm install googleapis
|
|
5464
|
+
* // ```
|
|
5465
|
+
*
|
|
5466
|
+
* const {google} = require('googleapis');
|
|
5467
|
+
* const dataform = google.dataform('v1beta1');
|
|
5468
|
+
*
|
|
5469
|
+
* async function main() {
|
|
5470
|
+
* const auth = new google.auth.GoogleAuth({
|
|
5471
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
5472
|
+
* scopes: [
|
|
5473
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
5474
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
5475
|
+
* ],
|
|
5476
|
+
* });
|
|
5477
|
+
*
|
|
5478
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
5479
|
+
* const authClient = await auth.getClient();
|
|
5480
|
+
* google.options({auth: authClient});
|
|
5481
|
+
*
|
|
5482
|
+
* // Do the magic
|
|
5483
|
+
* const res =
|
|
5484
|
+
* await dataform.projects.locations.repositories.workspaces.fetchFileGitStatuses(
|
|
5485
|
+
* {
|
|
5486
|
+
* // Required. The workspace's name.
|
|
5487
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie/workspaces/my-workspace',
|
|
5488
|
+
* },
|
|
5489
|
+
* );
|
|
5490
|
+
* console.log(res.data);
|
|
5491
|
+
*
|
|
5492
|
+
* // Example response
|
|
5493
|
+
* // {
|
|
5494
|
+
* // "uncommittedFileChanges": []
|
|
5495
|
+
* // }
|
|
5496
|
+
* }
|
|
5497
|
+
*
|
|
5498
|
+
* main().catch(e => {
|
|
5499
|
+
* console.error(e);
|
|
5500
|
+
* throw e;
|
|
5501
|
+
* });
|
|
5502
|
+
*
|
|
5503
|
+
* ```
|
|
2928
5504
|
*
|
|
2929
5505
|
* @param params - Parameters for request
|
|
2930
5506
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2931
5507
|
* @param callback - Optional callback that handles the response.
|
|
2932
5508
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2933
5509
|
*/
|
|
2934
|
-
fetchFileGitStatuses(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Fetchfilegitstatuses, options: StreamMethodOptions):
|
|
2935
|
-
fetchFileGitStatuses(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Fetchfilegitstatuses, options?: MethodOptions):
|
|
5510
|
+
fetchFileGitStatuses(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Fetchfilegitstatuses, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
5511
|
+
fetchFileGitStatuses(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Fetchfilegitstatuses, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$FetchFileGitStatusesResponse>>;
|
|
2936
5512
|
fetchFileGitStatuses(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Fetchfilegitstatuses, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2937
5513
|
fetchFileGitStatuses(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Fetchfilegitstatuses, options: MethodOptions | BodyResponseCallback<Schema$FetchFileGitStatusesResponse>, callback: BodyResponseCallback<Schema$FetchFileGitStatusesResponse>): void;
|
|
2938
5514
|
fetchFileGitStatuses(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Fetchfilegitstatuses, callback: BodyResponseCallback<Schema$FetchFileGitStatusesResponse>): void;
|
|
2939
5515
|
fetchFileGitStatuses(callback: BodyResponseCallback<Schema$FetchFileGitStatusesResponse>): void;
|
|
2940
5516
|
/**
|
|
2941
5517
|
* Fetches Git ahead/behind against a remote branch.
|
|
5518
|
+
* @example
|
|
5519
|
+
* ```js
|
|
5520
|
+
* // Before running the sample:
|
|
5521
|
+
* // - Enable the API at:
|
|
5522
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
5523
|
+
* // - Login into gcloud by running:
|
|
5524
|
+
* // ```sh
|
|
5525
|
+
* // $ gcloud auth application-default login
|
|
5526
|
+
* // ```
|
|
5527
|
+
* // - Install the npm module by running:
|
|
5528
|
+
* // ```sh
|
|
5529
|
+
* // $ npm install googleapis
|
|
5530
|
+
* // ```
|
|
5531
|
+
*
|
|
5532
|
+
* const {google} = require('googleapis');
|
|
5533
|
+
* const dataform = google.dataform('v1beta1');
|
|
5534
|
+
*
|
|
5535
|
+
* async function main() {
|
|
5536
|
+
* const auth = new google.auth.GoogleAuth({
|
|
5537
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
5538
|
+
* scopes: [
|
|
5539
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
5540
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
5541
|
+
* ],
|
|
5542
|
+
* });
|
|
5543
|
+
*
|
|
5544
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
5545
|
+
* const authClient = await auth.getClient();
|
|
5546
|
+
* google.options({auth: authClient});
|
|
5547
|
+
*
|
|
5548
|
+
* // Do the magic
|
|
5549
|
+
* const res =
|
|
5550
|
+
* await dataform.projects.locations.repositories.workspaces.fetchGitAheadBehind(
|
|
5551
|
+
* {
|
|
5552
|
+
* // Required. The workspace's name.
|
|
5553
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie/workspaces/my-workspace',
|
|
5554
|
+
* // Optional. The name of the branch in the Git remote against which this workspace should be compared. If left unset, the repository's default branch name will be used.
|
|
5555
|
+
* remoteBranch: 'placeholder-value',
|
|
5556
|
+
* },
|
|
5557
|
+
* );
|
|
5558
|
+
* console.log(res.data);
|
|
5559
|
+
*
|
|
5560
|
+
* // Example response
|
|
5561
|
+
* // {
|
|
5562
|
+
* // "commitsAhead": 0,
|
|
5563
|
+
* // "commitsBehind": 0
|
|
5564
|
+
* // }
|
|
5565
|
+
* }
|
|
5566
|
+
*
|
|
5567
|
+
* main().catch(e => {
|
|
5568
|
+
* console.error(e);
|
|
5569
|
+
* throw e;
|
|
5570
|
+
* });
|
|
5571
|
+
*
|
|
5572
|
+
* ```
|
|
2942
5573
|
*
|
|
2943
5574
|
* @param params - Parameters for request
|
|
2944
5575
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2945
5576
|
* @param callback - Optional callback that handles the response.
|
|
2946
5577
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2947
5578
|
*/
|
|
2948
|
-
fetchGitAheadBehind(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Fetchgitaheadbehind, options: StreamMethodOptions):
|
|
2949
|
-
fetchGitAheadBehind(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Fetchgitaheadbehind, options?: MethodOptions):
|
|
5579
|
+
fetchGitAheadBehind(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Fetchgitaheadbehind, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
5580
|
+
fetchGitAheadBehind(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Fetchgitaheadbehind, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$FetchGitAheadBehindResponse>>;
|
|
2950
5581
|
fetchGitAheadBehind(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Fetchgitaheadbehind, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2951
5582
|
fetchGitAheadBehind(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Fetchgitaheadbehind, options: MethodOptions | BodyResponseCallback<Schema$FetchGitAheadBehindResponse>, callback: BodyResponseCallback<Schema$FetchGitAheadBehindResponse>): void;
|
|
2952
5583
|
fetchGitAheadBehind(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Fetchgitaheadbehind, callback: BodyResponseCallback<Schema$FetchGitAheadBehindResponse>): void;
|
|
2953
5584
|
fetchGitAheadBehind(callback: BodyResponseCallback<Schema$FetchGitAheadBehindResponse>): void;
|
|
2954
5585
|
/**
|
|
2955
5586
|
* Fetches a single Workspace.
|
|
5587
|
+
* @example
|
|
5588
|
+
* ```js
|
|
5589
|
+
* // Before running the sample:
|
|
5590
|
+
* // - Enable the API at:
|
|
5591
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
5592
|
+
* // - Login into gcloud by running:
|
|
5593
|
+
* // ```sh
|
|
5594
|
+
* // $ gcloud auth application-default login
|
|
5595
|
+
* // ```
|
|
5596
|
+
* // - Install the npm module by running:
|
|
5597
|
+
* // ```sh
|
|
5598
|
+
* // $ npm install googleapis
|
|
5599
|
+
* // ```
|
|
5600
|
+
*
|
|
5601
|
+
* const {google} = require('googleapis');
|
|
5602
|
+
* const dataform = google.dataform('v1beta1');
|
|
5603
|
+
*
|
|
5604
|
+
* async function main() {
|
|
5605
|
+
* const auth = new google.auth.GoogleAuth({
|
|
5606
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
5607
|
+
* scopes: [
|
|
5608
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
5609
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
5610
|
+
* ],
|
|
5611
|
+
* });
|
|
5612
|
+
*
|
|
5613
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
5614
|
+
* const authClient = await auth.getClient();
|
|
5615
|
+
* google.options({auth: authClient});
|
|
5616
|
+
*
|
|
5617
|
+
* // Do the magic
|
|
5618
|
+
* const res = await dataform.projects.locations.repositories.workspaces.get({
|
|
5619
|
+
* // Required. The workspace's name.
|
|
5620
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie/workspaces/my-workspace',
|
|
5621
|
+
* });
|
|
5622
|
+
* console.log(res.data);
|
|
5623
|
+
*
|
|
5624
|
+
* // Example response
|
|
5625
|
+
* // {
|
|
5626
|
+
* // "createTime": "my_createTime",
|
|
5627
|
+
* // "dataEncryptionState": {},
|
|
5628
|
+
* // "internalMetadata": "my_internalMetadata",
|
|
5629
|
+
* // "name": "my_name"
|
|
5630
|
+
* // }
|
|
5631
|
+
* }
|
|
5632
|
+
*
|
|
5633
|
+
* main().catch(e => {
|
|
5634
|
+
* console.error(e);
|
|
5635
|
+
* throw e;
|
|
5636
|
+
* });
|
|
5637
|
+
*
|
|
5638
|
+
* ```
|
|
2956
5639
|
*
|
|
2957
5640
|
* @param params - Parameters for request
|
|
2958
5641
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2959
5642
|
* @param callback - Optional callback that handles the response.
|
|
2960
5643
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2961
5644
|
*/
|
|
2962
|
-
get(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Get, options: StreamMethodOptions):
|
|
2963
|
-
get(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Get, options?: MethodOptions):
|
|
5645
|
+
get(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Get, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
5646
|
+
get(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Get, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Workspace>>;
|
|
2964
5647
|
get(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Get, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2965
5648
|
get(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Get, options: MethodOptions | BodyResponseCallback<Schema$Workspace>, callback: BodyResponseCallback<Schema$Workspace>): void;
|
|
2966
5649
|
get(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Get, callback: BodyResponseCallback<Schema$Workspace>): void;
|
|
2967
5650
|
get(callback: BodyResponseCallback<Schema$Workspace>): void;
|
|
2968
5651
|
/**
|
|
2969
5652
|
* Gets the access control policy for a resource. Returns an empty policy if the resource exists and does not have a policy set.
|
|
5653
|
+
* @example
|
|
5654
|
+
* ```js
|
|
5655
|
+
* // Before running the sample:
|
|
5656
|
+
* // - Enable the API at:
|
|
5657
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
5658
|
+
* // - Login into gcloud by running:
|
|
5659
|
+
* // ```sh
|
|
5660
|
+
* // $ gcloud auth application-default login
|
|
5661
|
+
* // ```
|
|
5662
|
+
* // - Install the npm module by running:
|
|
5663
|
+
* // ```sh
|
|
5664
|
+
* // $ npm install googleapis
|
|
5665
|
+
* // ```
|
|
5666
|
+
*
|
|
5667
|
+
* const {google} = require('googleapis');
|
|
5668
|
+
* const dataform = google.dataform('v1beta1');
|
|
5669
|
+
*
|
|
5670
|
+
* async function main() {
|
|
5671
|
+
* const auth = new google.auth.GoogleAuth({
|
|
5672
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
5673
|
+
* scopes: [
|
|
5674
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
5675
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
5676
|
+
* ],
|
|
5677
|
+
* });
|
|
5678
|
+
*
|
|
5679
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
5680
|
+
* const authClient = await auth.getClient();
|
|
5681
|
+
* google.options({auth: authClient});
|
|
5682
|
+
*
|
|
5683
|
+
* // Do the magic
|
|
5684
|
+
* const res =
|
|
5685
|
+
* await dataform.projects.locations.repositories.workspaces.getIamPolicy({
|
|
5686
|
+
* // Optional. The maximum policy version that will be used to format the policy. Valid values are 0, 1, and 3. Requests specifying an invalid value will be rejected. Requests for policies with any conditional role bindings must specify version 3. Policies with no conditional role bindings may specify any valid value or leave the field unset. The policy in the response might use the policy version that you specified, or it might use a lower policy version. For example, if you specify version 3, but the policy has no conditional role bindings, the response uses version 1. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
|
|
5687
|
+
* 'options.requestedPolicyVersion': 'placeholder-value',
|
|
5688
|
+
* // REQUIRED: The resource for which the policy is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.
|
|
5689
|
+
* resource:
|
|
5690
|
+
* 'projects/my-project/locations/my-location/repositories/my-repositorie/workspaces/my-workspace',
|
|
5691
|
+
* });
|
|
5692
|
+
* console.log(res.data);
|
|
5693
|
+
*
|
|
5694
|
+
* // Example response
|
|
5695
|
+
* // {
|
|
5696
|
+
* // "bindings": [],
|
|
5697
|
+
* // "etag": "my_etag",
|
|
5698
|
+
* // "version": 0
|
|
5699
|
+
* // }
|
|
5700
|
+
* }
|
|
5701
|
+
*
|
|
5702
|
+
* main().catch(e => {
|
|
5703
|
+
* console.error(e);
|
|
5704
|
+
* throw e;
|
|
5705
|
+
* });
|
|
5706
|
+
*
|
|
5707
|
+
* ```
|
|
2970
5708
|
*
|
|
2971
5709
|
* @param params - Parameters for request
|
|
2972
5710
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2973
5711
|
* @param callback - Optional callback that handles the response.
|
|
2974
5712
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2975
5713
|
*/
|
|
2976
|
-
getIamPolicy(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Getiampolicy, options: StreamMethodOptions):
|
|
2977
|
-
getIamPolicy(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Getiampolicy, options?: MethodOptions):
|
|
5714
|
+
getIamPolicy(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Getiampolicy, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
5715
|
+
getIamPolicy(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Getiampolicy, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Policy>>;
|
|
2978
5716
|
getIamPolicy(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Getiampolicy, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2979
5717
|
getIamPolicy(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Getiampolicy, options: MethodOptions | BodyResponseCallback<Schema$Policy>, callback: BodyResponseCallback<Schema$Policy>): void;
|
|
2980
5718
|
getIamPolicy(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Getiampolicy, callback: BodyResponseCallback<Schema$Policy>): void;
|
|
2981
5719
|
getIamPolicy(callback: BodyResponseCallback<Schema$Policy>): void;
|
|
2982
5720
|
/**
|
|
2983
5721
|
* Installs dependency NPM packages (inside a Workspace).
|
|
5722
|
+
* @example
|
|
5723
|
+
* ```js
|
|
5724
|
+
* // Before running the sample:
|
|
5725
|
+
* // - Enable the API at:
|
|
5726
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
5727
|
+
* // - Login into gcloud by running:
|
|
5728
|
+
* // ```sh
|
|
5729
|
+
* // $ gcloud auth application-default login
|
|
5730
|
+
* // ```
|
|
5731
|
+
* // - Install the npm module by running:
|
|
5732
|
+
* // ```sh
|
|
5733
|
+
* // $ npm install googleapis
|
|
5734
|
+
* // ```
|
|
5735
|
+
*
|
|
5736
|
+
* const {google} = require('googleapis');
|
|
5737
|
+
* const dataform = google.dataform('v1beta1');
|
|
5738
|
+
*
|
|
5739
|
+
* async function main() {
|
|
5740
|
+
* const auth = new google.auth.GoogleAuth({
|
|
5741
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
5742
|
+
* scopes: [
|
|
5743
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
5744
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
5745
|
+
* ],
|
|
5746
|
+
* });
|
|
5747
|
+
*
|
|
5748
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
5749
|
+
* const authClient = await auth.getClient();
|
|
5750
|
+
* google.options({auth: authClient});
|
|
5751
|
+
*
|
|
5752
|
+
* // Do the magic
|
|
5753
|
+
* const res =
|
|
5754
|
+
* await dataform.projects.locations.repositories.workspaces.installNpmPackages(
|
|
5755
|
+
* {
|
|
5756
|
+
* // Required. The workspace's name.
|
|
5757
|
+
* workspace:
|
|
5758
|
+
* 'projects/my-project/locations/my-location/repositories/my-repositorie/workspaces/my-workspace',
|
|
5759
|
+
*
|
|
5760
|
+
* // Request body metadata
|
|
5761
|
+
* requestBody: {
|
|
5762
|
+
* // request body parameters
|
|
5763
|
+
* // {}
|
|
5764
|
+
* },
|
|
5765
|
+
* },
|
|
5766
|
+
* );
|
|
5767
|
+
* console.log(res.data);
|
|
5768
|
+
*
|
|
5769
|
+
* // Example response
|
|
5770
|
+
* // {}
|
|
5771
|
+
* }
|
|
5772
|
+
*
|
|
5773
|
+
* main().catch(e => {
|
|
5774
|
+
* console.error(e);
|
|
5775
|
+
* throw e;
|
|
5776
|
+
* });
|
|
5777
|
+
*
|
|
5778
|
+
* ```
|
|
2984
5779
|
*
|
|
2985
5780
|
* @param params - Parameters for request
|
|
2986
5781
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
2987
5782
|
* @param callback - Optional callback that handles the response.
|
|
2988
5783
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
2989
5784
|
*/
|
|
2990
|
-
installNpmPackages(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Installnpmpackages, options: StreamMethodOptions):
|
|
2991
|
-
installNpmPackages(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Installnpmpackages, options?: MethodOptions):
|
|
5785
|
+
installNpmPackages(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Installnpmpackages, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
5786
|
+
installNpmPackages(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Installnpmpackages, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$InstallNpmPackagesResponse>>;
|
|
2992
5787
|
installNpmPackages(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Installnpmpackages, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
2993
5788
|
installNpmPackages(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Installnpmpackages, options: MethodOptions | BodyResponseCallback<Schema$InstallNpmPackagesResponse>, callback: BodyResponseCallback<Schema$InstallNpmPackagesResponse>): void;
|
|
2994
5789
|
installNpmPackages(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Installnpmpackages, callback: BodyResponseCallback<Schema$InstallNpmPackagesResponse>): void;
|
|
2995
5790
|
installNpmPackages(callback: BodyResponseCallback<Schema$InstallNpmPackagesResponse>): void;
|
|
2996
5791
|
/**
|
|
2997
5792
|
* Lists Workspaces in a given Repository.
|
|
5793
|
+
* @example
|
|
5794
|
+
* ```js
|
|
5795
|
+
* // Before running the sample:
|
|
5796
|
+
* // - Enable the API at:
|
|
5797
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
5798
|
+
* // - Login into gcloud by running:
|
|
5799
|
+
* // ```sh
|
|
5800
|
+
* // $ gcloud auth application-default login
|
|
5801
|
+
* // ```
|
|
5802
|
+
* // - Install the npm module by running:
|
|
5803
|
+
* // ```sh
|
|
5804
|
+
* // $ npm install googleapis
|
|
5805
|
+
* // ```
|
|
5806
|
+
*
|
|
5807
|
+
* const {google} = require('googleapis');
|
|
5808
|
+
* const dataform = google.dataform('v1beta1');
|
|
5809
|
+
*
|
|
5810
|
+
* async function main() {
|
|
5811
|
+
* const auth = new google.auth.GoogleAuth({
|
|
5812
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
5813
|
+
* scopes: [
|
|
5814
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
5815
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
5816
|
+
* ],
|
|
5817
|
+
* });
|
|
5818
|
+
*
|
|
5819
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
5820
|
+
* const authClient = await auth.getClient();
|
|
5821
|
+
* google.options({auth: authClient});
|
|
5822
|
+
*
|
|
5823
|
+
* // Do the magic
|
|
5824
|
+
* const res = await dataform.projects.locations.repositories.workspaces.list({
|
|
5825
|
+
* // Optional. Filter for the returned list.
|
|
5826
|
+
* filter: 'placeholder-value',
|
|
5827
|
+
* // Optional. This field only supports ordering by `name`. If unspecified, the server will choose the ordering. If specified, the default order is ascending for the `name` field.
|
|
5828
|
+
* orderBy: 'placeholder-value',
|
|
5829
|
+
* // Optional. Maximum number of workspaces to return. The server may return fewer items than requested. If unspecified, the server will pick an appropriate default.
|
|
5830
|
+
* pageSize: 'placeholder-value',
|
|
5831
|
+
* // Optional. Page token received from a previous `ListWorkspaces` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `ListWorkspaces`, with the exception of `page_size`, must match the call that provided the page token.
|
|
5832
|
+
* pageToken: 'placeholder-value',
|
|
5833
|
+
* // Required. The repository in which to list workspaces. Must be in the format `projects/x/locations/x/repositories/x`.
|
|
5834
|
+
* parent:
|
|
5835
|
+
* 'projects/my-project/locations/my-location/repositories/my-repositorie',
|
|
5836
|
+
* });
|
|
5837
|
+
* console.log(res.data);
|
|
5838
|
+
*
|
|
5839
|
+
* // Example response
|
|
5840
|
+
* // {
|
|
5841
|
+
* // "nextPageToken": "my_nextPageToken",
|
|
5842
|
+
* // "unreachable": [],
|
|
5843
|
+
* // "workspaces": []
|
|
5844
|
+
* // }
|
|
5845
|
+
* }
|
|
5846
|
+
*
|
|
5847
|
+
* main().catch(e => {
|
|
5848
|
+
* console.error(e);
|
|
5849
|
+
* throw e;
|
|
5850
|
+
* });
|
|
5851
|
+
*
|
|
5852
|
+
* ```
|
|
2998
5853
|
*
|
|
2999
5854
|
* @param params - Parameters for request
|
|
3000
5855
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
3001
5856
|
* @param callback - Optional callback that handles the response.
|
|
3002
5857
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
3003
5858
|
*/
|
|
3004
|
-
list(params: Params$Resource$Projects$Locations$Repositories$Workspaces$List, options: StreamMethodOptions):
|
|
3005
|
-
list(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$List, options?: MethodOptions):
|
|
5859
|
+
list(params: Params$Resource$Projects$Locations$Repositories$Workspaces$List, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
5860
|
+
list(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$List, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ListWorkspacesResponse>>;
|
|
3006
5861
|
list(params: Params$Resource$Projects$Locations$Repositories$Workspaces$List, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
3007
5862
|
list(params: Params$Resource$Projects$Locations$Repositories$Workspaces$List, options: MethodOptions | BodyResponseCallback<Schema$ListWorkspacesResponse>, callback: BodyResponseCallback<Schema$ListWorkspacesResponse>): void;
|
|
3008
5863
|
list(params: Params$Resource$Projects$Locations$Repositories$Workspaces$List, callback: BodyResponseCallback<Schema$ListWorkspacesResponse>): void;
|
|
3009
5864
|
list(callback: BodyResponseCallback<Schema$ListWorkspacesResponse>): void;
|
|
3010
5865
|
/**
|
|
3011
5866
|
* Creates a directory inside a Workspace.
|
|
5867
|
+
* @example
|
|
5868
|
+
* ```js
|
|
5869
|
+
* // Before running the sample:
|
|
5870
|
+
* // - Enable the API at:
|
|
5871
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
5872
|
+
* // - Login into gcloud by running:
|
|
5873
|
+
* // ```sh
|
|
5874
|
+
* // $ gcloud auth application-default login
|
|
5875
|
+
* // ```
|
|
5876
|
+
* // - Install the npm module by running:
|
|
5877
|
+
* // ```sh
|
|
5878
|
+
* // $ npm install googleapis
|
|
5879
|
+
* // ```
|
|
5880
|
+
*
|
|
5881
|
+
* const {google} = require('googleapis');
|
|
5882
|
+
* const dataform = google.dataform('v1beta1');
|
|
5883
|
+
*
|
|
5884
|
+
* async function main() {
|
|
5885
|
+
* const auth = new google.auth.GoogleAuth({
|
|
5886
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
5887
|
+
* scopes: [
|
|
5888
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
5889
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
5890
|
+
* ],
|
|
5891
|
+
* });
|
|
5892
|
+
*
|
|
5893
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
5894
|
+
* const authClient = await auth.getClient();
|
|
5895
|
+
* google.options({auth: authClient});
|
|
5896
|
+
*
|
|
5897
|
+
* // Do the magic
|
|
5898
|
+
* const res =
|
|
5899
|
+
* await dataform.projects.locations.repositories.workspaces.makeDirectory({
|
|
5900
|
+
* // Required. The workspace's name.
|
|
5901
|
+
* workspace:
|
|
5902
|
+
* 'projects/my-project/locations/my-location/repositories/my-repositorie/workspaces/my-workspace',
|
|
5903
|
+
*
|
|
5904
|
+
* // Request body metadata
|
|
5905
|
+
* requestBody: {
|
|
5906
|
+
* // request body parameters
|
|
5907
|
+
* // {
|
|
5908
|
+
* // "path": "my_path"
|
|
5909
|
+
* // }
|
|
5910
|
+
* },
|
|
5911
|
+
* });
|
|
5912
|
+
* console.log(res.data);
|
|
5913
|
+
*
|
|
5914
|
+
* // Example response
|
|
5915
|
+
* // {}
|
|
5916
|
+
* }
|
|
5917
|
+
*
|
|
5918
|
+
* main().catch(e => {
|
|
5919
|
+
* console.error(e);
|
|
5920
|
+
* throw e;
|
|
5921
|
+
* });
|
|
5922
|
+
*
|
|
5923
|
+
* ```
|
|
3012
5924
|
*
|
|
3013
5925
|
* @param params - Parameters for request
|
|
3014
5926
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
3015
5927
|
* @param callback - Optional callback that handles the response.
|
|
3016
5928
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
3017
5929
|
*/
|
|
3018
|
-
makeDirectory(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Makedirectory, options: StreamMethodOptions):
|
|
3019
|
-
makeDirectory(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Makedirectory, options?: MethodOptions):
|
|
5930
|
+
makeDirectory(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Makedirectory, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
5931
|
+
makeDirectory(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Makedirectory, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$MakeDirectoryResponse>>;
|
|
3020
5932
|
makeDirectory(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Makedirectory, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
3021
5933
|
makeDirectory(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Makedirectory, options: MethodOptions | BodyResponseCallback<Schema$MakeDirectoryResponse>, callback: BodyResponseCallback<Schema$MakeDirectoryResponse>): void;
|
|
3022
5934
|
makeDirectory(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Makedirectory, callback: BodyResponseCallback<Schema$MakeDirectoryResponse>): void;
|
|
3023
5935
|
makeDirectory(callback: BodyResponseCallback<Schema$MakeDirectoryResponse>): void;
|
|
3024
5936
|
/**
|
|
3025
5937
|
* Moves a directory (inside a Workspace), and all of its contents, to a new location.
|
|
5938
|
+
* @example
|
|
5939
|
+
* ```js
|
|
5940
|
+
* // Before running the sample:
|
|
5941
|
+
* // - Enable the API at:
|
|
5942
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
5943
|
+
* // - Login into gcloud by running:
|
|
5944
|
+
* // ```sh
|
|
5945
|
+
* // $ gcloud auth application-default login
|
|
5946
|
+
* // ```
|
|
5947
|
+
* // - Install the npm module by running:
|
|
5948
|
+
* // ```sh
|
|
5949
|
+
* // $ npm install googleapis
|
|
5950
|
+
* // ```
|
|
5951
|
+
*
|
|
5952
|
+
* const {google} = require('googleapis');
|
|
5953
|
+
* const dataform = google.dataform('v1beta1');
|
|
5954
|
+
*
|
|
5955
|
+
* async function main() {
|
|
5956
|
+
* const auth = new google.auth.GoogleAuth({
|
|
5957
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
5958
|
+
* scopes: [
|
|
5959
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
5960
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
5961
|
+
* ],
|
|
5962
|
+
* });
|
|
5963
|
+
*
|
|
5964
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
5965
|
+
* const authClient = await auth.getClient();
|
|
5966
|
+
* google.options({auth: authClient});
|
|
5967
|
+
*
|
|
5968
|
+
* // Do the magic
|
|
5969
|
+
* const res =
|
|
5970
|
+
* await dataform.projects.locations.repositories.workspaces.moveDirectory({
|
|
5971
|
+
* // Required. The workspace's name.
|
|
5972
|
+
* workspace:
|
|
5973
|
+
* 'projects/my-project/locations/my-location/repositories/my-repositorie/workspaces/my-workspace',
|
|
5974
|
+
*
|
|
5975
|
+
* // Request body metadata
|
|
5976
|
+
* requestBody: {
|
|
5977
|
+
* // request body parameters
|
|
5978
|
+
* // {
|
|
5979
|
+
* // "newPath": "my_newPath",
|
|
5980
|
+
* // "path": "my_path"
|
|
5981
|
+
* // }
|
|
5982
|
+
* },
|
|
5983
|
+
* });
|
|
5984
|
+
* console.log(res.data);
|
|
5985
|
+
*
|
|
5986
|
+
* // Example response
|
|
5987
|
+
* // {}
|
|
5988
|
+
* }
|
|
5989
|
+
*
|
|
5990
|
+
* main().catch(e => {
|
|
5991
|
+
* console.error(e);
|
|
5992
|
+
* throw e;
|
|
5993
|
+
* });
|
|
5994
|
+
*
|
|
5995
|
+
* ```
|
|
3026
5996
|
*
|
|
3027
5997
|
* @param params - Parameters for request
|
|
3028
5998
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
3029
5999
|
* @param callback - Optional callback that handles the response.
|
|
3030
6000
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
3031
6001
|
*/
|
|
3032
|
-
moveDirectory(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Movedirectory, options: StreamMethodOptions):
|
|
3033
|
-
moveDirectory(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Movedirectory, options?: MethodOptions):
|
|
6002
|
+
moveDirectory(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Movedirectory, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
6003
|
+
moveDirectory(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Movedirectory, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$MoveDirectoryResponse>>;
|
|
3034
6004
|
moveDirectory(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Movedirectory, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
3035
6005
|
moveDirectory(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Movedirectory, options: MethodOptions | BodyResponseCallback<Schema$MoveDirectoryResponse>, callback: BodyResponseCallback<Schema$MoveDirectoryResponse>): void;
|
|
3036
6006
|
moveDirectory(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Movedirectory, callback: BodyResponseCallback<Schema$MoveDirectoryResponse>): void;
|
|
3037
6007
|
moveDirectory(callback: BodyResponseCallback<Schema$MoveDirectoryResponse>): void;
|
|
3038
6008
|
/**
|
|
3039
6009
|
* Moves a file (inside a Workspace) to a new location.
|
|
6010
|
+
* @example
|
|
6011
|
+
* ```js
|
|
6012
|
+
* // Before running the sample:
|
|
6013
|
+
* // - Enable the API at:
|
|
6014
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
6015
|
+
* // - Login into gcloud by running:
|
|
6016
|
+
* // ```sh
|
|
6017
|
+
* // $ gcloud auth application-default login
|
|
6018
|
+
* // ```
|
|
6019
|
+
* // - Install the npm module by running:
|
|
6020
|
+
* // ```sh
|
|
6021
|
+
* // $ npm install googleapis
|
|
6022
|
+
* // ```
|
|
6023
|
+
*
|
|
6024
|
+
* const {google} = require('googleapis');
|
|
6025
|
+
* const dataform = google.dataform('v1beta1');
|
|
6026
|
+
*
|
|
6027
|
+
* async function main() {
|
|
6028
|
+
* const auth = new google.auth.GoogleAuth({
|
|
6029
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
6030
|
+
* scopes: [
|
|
6031
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
6032
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
6033
|
+
* ],
|
|
6034
|
+
* });
|
|
6035
|
+
*
|
|
6036
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
6037
|
+
* const authClient = await auth.getClient();
|
|
6038
|
+
* google.options({auth: authClient});
|
|
6039
|
+
*
|
|
6040
|
+
* // Do the magic
|
|
6041
|
+
* const res =
|
|
6042
|
+
* await dataform.projects.locations.repositories.workspaces.moveFile({
|
|
6043
|
+
* // Required. The workspace's name.
|
|
6044
|
+
* workspace:
|
|
6045
|
+
* 'projects/my-project/locations/my-location/repositories/my-repositorie/workspaces/my-workspace',
|
|
6046
|
+
*
|
|
6047
|
+
* // Request body metadata
|
|
6048
|
+
* requestBody: {
|
|
6049
|
+
* // request body parameters
|
|
6050
|
+
* // {
|
|
6051
|
+
* // "newPath": "my_newPath",
|
|
6052
|
+
* // "path": "my_path"
|
|
6053
|
+
* // }
|
|
6054
|
+
* },
|
|
6055
|
+
* });
|
|
6056
|
+
* console.log(res.data);
|
|
6057
|
+
*
|
|
6058
|
+
* // Example response
|
|
6059
|
+
* // {}
|
|
6060
|
+
* }
|
|
6061
|
+
*
|
|
6062
|
+
* main().catch(e => {
|
|
6063
|
+
* console.error(e);
|
|
6064
|
+
* throw e;
|
|
6065
|
+
* });
|
|
6066
|
+
*
|
|
6067
|
+
* ```
|
|
3040
6068
|
*
|
|
3041
6069
|
* @param params - Parameters for request
|
|
3042
6070
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
3043
6071
|
* @param callback - Optional callback that handles the response.
|
|
3044
6072
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
3045
6073
|
*/
|
|
3046
|
-
moveFile(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Movefile, options: StreamMethodOptions):
|
|
3047
|
-
moveFile(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Movefile, options?: MethodOptions):
|
|
6074
|
+
moveFile(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Movefile, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
6075
|
+
moveFile(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Movefile, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$MoveFileResponse>>;
|
|
3048
6076
|
moveFile(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Movefile, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
3049
6077
|
moveFile(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Movefile, options: MethodOptions | BodyResponseCallback<Schema$MoveFileResponse>, callback: BodyResponseCallback<Schema$MoveFileResponse>): void;
|
|
3050
6078
|
moveFile(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Movefile, callback: BodyResponseCallback<Schema$MoveFileResponse>): void;
|
|
3051
6079
|
moveFile(callback: BodyResponseCallback<Schema$MoveFileResponse>): void;
|
|
3052
6080
|
/**
|
|
3053
6081
|
* Pulls Git commits from the Repository's remote into a Workspace.
|
|
6082
|
+
* @example
|
|
6083
|
+
* ```js
|
|
6084
|
+
* // Before running the sample:
|
|
6085
|
+
* // - Enable the API at:
|
|
6086
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
6087
|
+
* // - Login into gcloud by running:
|
|
6088
|
+
* // ```sh
|
|
6089
|
+
* // $ gcloud auth application-default login
|
|
6090
|
+
* // ```
|
|
6091
|
+
* // - Install the npm module by running:
|
|
6092
|
+
* // ```sh
|
|
6093
|
+
* // $ npm install googleapis
|
|
6094
|
+
* // ```
|
|
6095
|
+
*
|
|
6096
|
+
* const {google} = require('googleapis');
|
|
6097
|
+
* const dataform = google.dataform('v1beta1');
|
|
6098
|
+
*
|
|
6099
|
+
* async function main() {
|
|
6100
|
+
* const auth = new google.auth.GoogleAuth({
|
|
6101
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
6102
|
+
* scopes: [
|
|
6103
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
6104
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
6105
|
+
* ],
|
|
6106
|
+
* });
|
|
6107
|
+
*
|
|
6108
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
6109
|
+
* const authClient = await auth.getClient();
|
|
6110
|
+
* google.options({auth: authClient});
|
|
6111
|
+
*
|
|
6112
|
+
* // Do the magic
|
|
6113
|
+
* const res = await dataform.projects.locations.repositories.workspaces.pull({
|
|
6114
|
+
* // Required. The workspace's name.
|
|
6115
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie/workspaces/my-workspace',
|
|
6116
|
+
*
|
|
6117
|
+
* // Request body metadata
|
|
6118
|
+
* requestBody: {
|
|
6119
|
+
* // request body parameters
|
|
6120
|
+
* // {
|
|
6121
|
+
* // "author": {},
|
|
6122
|
+
* // "remoteBranch": "my_remoteBranch"
|
|
6123
|
+
* // }
|
|
6124
|
+
* },
|
|
6125
|
+
* });
|
|
6126
|
+
* console.log(res.data);
|
|
6127
|
+
*
|
|
6128
|
+
* // Example response
|
|
6129
|
+
* // {}
|
|
6130
|
+
* }
|
|
6131
|
+
*
|
|
6132
|
+
* main().catch(e => {
|
|
6133
|
+
* console.error(e);
|
|
6134
|
+
* throw e;
|
|
6135
|
+
* });
|
|
6136
|
+
*
|
|
6137
|
+
* ```
|
|
3054
6138
|
*
|
|
3055
6139
|
* @param params - Parameters for request
|
|
3056
6140
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
3057
6141
|
* @param callback - Optional callback that handles the response.
|
|
3058
6142
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
3059
6143
|
*/
|
|
3060
|
-
pull(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Pull, options: StreamMethodOptions):
|
|
3061
|
-
pull(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Pull, options?: MethodOptions):
|
|
6144
|
+
pull(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Pull, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
6145
|
+
pull(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Pull, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$PullGitCommitsResponse>>;
|
|
3062
6146
|
pull(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Pull, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
3063
6147
|
pull(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Pull, options: MethodOptions | BodyResponseCallback<Schema$PullGitCommitsResponse>, callback: BodyResponseCallback<Schema$PullGitCommitsResponse>): void;
|
|
3064
6148
|
pull(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Pull, callback: BodyResponseCallback<Schema$PullGitCommitsResponse>): void;
|
|
3065
6149
|
pull(callback: BodyResponseCallback<Schema$PullGitCommitsResponse>): void;
|
|
3066
6150
|
/**
|
|
3067
6151
|
* Pushes Git commits from a Workspace to the Repository's remote.
|
|
6152
|
+
* @example
|
|
6153
|
+
* ```js
|
|
6154
|
+
* // Before running the sample:
|
|
6155
|
+
* // - Enable the API at:
|
|
6156
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
6157
|
+
* // - Login into gcloud by running:
|
|
6158
|
+
* // ```sh
|
|
6159
|
+
* // $ gcloud auth application-default login
|
|
6160
|
+
* // ```
|
|
6161
|
+
* // - Install the npm module by running:
|
|
6162
|
+
* // ```sh
|
|
6163
|
+
* // $ npm install googleapis
|
|
6164
|
+
* // ```
|
|
6165
|
+
*
|
|
6166
|
+
* const {google} = require('googleapis');
|
|
6167
|
+
* const dataform = google.dataform('v1beta1');
|
|
6168
|
+
*
|
|
6169
|
+
* async function main() {
|
|
6170
|
+
* const auth = new google.auth.GoogleAuth({
|
|
6171
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
6172
|
+
* scopes: [
|
|
6173
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
6174
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
6175
|
+
* ],
|
|
6176
|
+
* });
|
|
6177
|
+
*
|
|
6178
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
6179
|
+
* const authClient = await auth.getClient();
|
|
6180
|
+
* google.options({auth: authClient});
|
|
6181
|
+
*
|
|
6182
|
+
* // Do the magic
|
|
6183
|
+
* const res = await dataform.projects.locations.repositories.workspaces.push({
|
|
6184
|
+
* // Required. The workspace's name.
|
|
6185
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie/workspaces/my-workspace',
|
|
6186
|
+
*
|
|
6187
|
+
* // Request body metadata
|
|
6188
|
+
* requestBody: {
|
|
6189
|
+
* // request body parameters
|
|
6190
|
+
* // {
|
|
6191
|
+
* // "remoteBranch": "my_remoteBranch"
|
|
6192
|
+
* // }
|
|
6193
|
+
* },
|
|
6194
|
+
* });
|
|
6195
|
+
* console.log(res.data);
|
|
6196
|
+
*
|
|
6197
|
+
* // Example response
|
|
6198
|
+
* // {}
|
|
6199
|
+
* }
|
|
6200
|
+
*
|
|
6201
|
+
* main().catch(e => {
|
|
6202
|
+
* console.error(e);
|
|
6203
|
+
* throw e;
|
|
6204
|
+
* });
|
|
6205
|
+
*
|
|
6206
|
+
* ```
|
|
3068
6207
|
*
|
|
3069
6208
|
* @param params - Parameters for request
|
|
3070
6209
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
3071
6210
|
* @param callback - Optional callback that handles the response.
|
|
3072
6211
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
3073
6212
|
*/
|
|
3074
|
-
push(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Push, options: StreamMethodOptions):
|
|
3075
|
-
push(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Push, options?: MethodOptions):
|
|
6213
|
+
push(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Push, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
6214
|
+
push(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Push, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$PushGitCommitsResponse>>;
|
|
3076
6215
|
push(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Push, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
3077
6216
|
push(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Push, options: MethodOptions | BodyResponseCallback<Schema$PushGitCommitsResponse>, callback: BodyResponseCallback<Schema$PushGitCommitsResponse>): void;
|
|
3078
6217
|
push(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Push, callback: BodyResponseCallback<Schema$PushGitCommitsResponse>): void;
|
|
3079
6218
|
push(callback: BodyResponseCallback<Schema$PushGitCommitsResponse>): void;
|
|
3080
6219
|
/**
|
|
3081
6220
|
* Returns the contents of a given Workspace directory.
|
|
6221
|
+
* @example
|
|
6222
|
+
* ```js
|
|
6223
|
+
* // Before running the sample:
|
|
6224
|
+
* // - Enable the API at:
|
|
6225
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
6226
|
+
* // - Login into gcloud by running:
|
|
6227
|
+
* // ```sh
|
|
6228
|
+
* // $ gcloud auth application-default login
|
|
6229
|
+
* // ```
|
|
6230
|
+
* // - Install the npm module by running:
|
|
6231
|
+
* // ```sh
|
|
6232
|
+
* // $ npm install googleapis
|
|
6233
|
+
* // ```
|
|
6234
|
+
*
|
|
6235
|
+
* const {google} = require('googleapis');
|
|
6236
|
+
* const dataform = google.dataform('v1beta1');
|
|
6237
|
+
*
|
|
6238
|
+
* async function main() {
|
|
6239
|
+
* const auth = new google.auth.GoogleAuth({
|
|
6240
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
6241
|
+
* scopes: [
|
|
6242
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
6243
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
6244
|
+
* ],
|
|
6245
|
+
* });
|
|
6246
|
+
*
|
|
6247
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
6248
|
+
* const authClient = await auth.getClient();
|
|
6249
|
+
* google.options({auth: authClient});
|
|
6250
|
+
*
|
|
6251
|
+
* // Do the magic
|
|
6252
|
+
* const res =
|
|
6253
|
+
* await dataform.projects.locations.repositories.workspaces.queryDirectoryContents(
|
|
6254
|
+
* {
|
|
6255
|
+
* // Optional. Maximum number of paths to return. The server may return fewer items than requested. If unspecified, the server will pick an appropriate default.
|
|
6256
|
+
* pageSize: 'placeholder-value',
|
|
6257
|
+
* // Optional. Page token received from a previous `QueryDirectoryContents` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `QueryDirectoryContents`, with the exception of `page_size`, must match the call that provided the page token.
|
|
6258
|
+
* pageToken: 'placeholder-value',
|
|
6259
|
+
* // Optional. The directory's full path including directory name, relative to the workspace root. If left unset, the workspace root is used.
|
|
6260
|
+
* path: 'placeholder-value',
|
|
6261
|
+
* // Required. The workspace's name.
|
|
6262
|
+
* workspace:
|
|
6263
|
+
* 'projects/my-project/locations/my-location/repositories/my-repositorie/workspaces/my-workspace',
|
|
6264
|
+
* },
|
|
6265
|
+
* );
|
|
6266
|
+
* console.log(res.data);
|
|
6267
|
+
*
|
|
6268
|
+
* // Example response
|
|
6269
|
+
* // {
|
|
6270
|
+
* // "directoryEntries": [],
|
|
6271
|
+
* // "nextPageToken": "my_nextPageToken"
|
|
6272
|
+
* // }
|
|
6273
|
+
* }
|
|
6274
|
+
*
|
|
6275
|
+
* main().catch(e => {
|
|
6276
|
+
* console.error(e);
|
|
6277
|
+
* throw e;
|
|
6278
|
+
* });
|
|
6279
|
+
*
|
|
6280
|
+
* ```
|
|
3082
6281
|
*
|
|
3083
6282
|
* @param params - Parameters for request
|
|
3084
6283
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
3085
6284
|
* @param callback - Optional callback that handles the response.
|
|
3086
6285
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
3087
6286
|
*/
|
|
3088
|
-
queryDirectoryContents(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Querydirectorycontents, options: StreamMethodOptions):
|
|
3089
|
-
queryDirectoryContents(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Querydirectorycontents, options?: MethodOptions):
|
|
6287
|
+
queryDirectoryContents(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Querydirectorycontents, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
6288
|
+
queryDirectoryContents(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Querydirectorycontents, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$QueryDirectoryContentsResponse>>;
|
|
3090
6289
|
queryDirectoryContents(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Querydirectorycontents, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
3091
6290
|
queryDirectoryContents(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Querydirectorycontents, options: MethodOptions | BodyResponseCallback<Schema$QueryDirectoryContentsResponse>, callback: BodyResponseCallback<Schema$QueryDirectoryContentsResponse>): void;
|
|
3092
6291
|
queryDirectoryContents(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Querydirectorycontents, callback: BodyResponseCallback<Schema$QueryDirectoryContentsResponse>): void;
|
|
3093
6292
|
queryDirectoryContents(callback: BodyResponseCallback<Schema$QueryDirectoryContentsResponse>): void;
|
|
3094
6293
|
/**
|
|
3095
6294
|
* Returns the contents of a file (inside a Workspace).
|
|
6295
|
+
* @example
|
|
6296
|
+
* ```js
|
|
6297
|
+
* // Before running the sample:
|
|
6298
|
+
* // - Enable the API at:
|
|
6299
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
6300
|
+
* // - Login into gcloud by running:
|
|
6301
|
+
* // ```sh
|
|
6302
|
+
* // $ gcloud auth application-default login
|
|
6303
|
+
* // ```
|
|
6304
|
+
* // - Install the npm module by running:
|
|
6305
|
+
* // ```sh
|
|
6306
|
+
* // $ npm install googleapis
|
|
6307
|
+
* // ```
|
|
6308
|
+
*
|
|
6309
|
+
* const {google} = require('googleapis');
|
|
6310
|
+
* const dataform = google.dataform('v1beta1');
|
|
6311
|
+
*
|
|
6312
|
+
* async function main() {
|
|
6313
|
+
* const auth = new google.auth.GoogleAuth({
|
|
6314
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
6315
|
+
* scopes: [
|
|
6316
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
6317
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
6318
|
+
* ],
|
|
6319
|
+
* });
|
|
6320
|
+
*
|
|
6321
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
6322
|
+
* const authClient = await auth.getClient();
|
|
6323
|
+
* google.options({auth: authClient});
|
|
6324
|
+
*
|
|
6325
|
+
* // Do the magic
|
|
6326
|
+
* const res =
|
|
6327
|
+
* await dataform.projects.locations.repositories.workspaces.readFile({
|
|
6328
|
+
* // Required. The file's full path including filename, relative to the workspace root.
|
|
6329
|
+
* path: 'placeholder-value',
|
|
6330
|
+
* // Optional. The Git revision of the file to return. If left empty, the current contents of `path` will be returned.
|
|
6331
|
+
* revision: 'placeholder-value',
|
|
6332
|
+
* // Required. The workspace's name.
|
|
6333
|
+
* workspace:
|
|
6334
|
+
* 'projects/my-project/locations/my-location/repositories/my-repositorie/workspaces/my-workspace',
|
|
6335
|
+
* });
|
|
6336
|
+
* console.log(res.data);
|
|
6337
|
+
*
|
|
6338
|
+
* // Example response
|
|
6339
|
+
* // {
|
|
6340
|
+
* // "fileContents": "my_fileContents"
|
|
6341
|
+
* // }
|
|
6342
|
+
* }
|
|
6343
|
+
*
|
|
6344
|
+
* main().catch(e => {
|
|
6345
|
+
* console.error(e);
|
|
6346
|
+
* throw e;
|
|
6347
|
+
* });
|
|
6348
|
+
*
|
|
6349
|
+
* ```
|
|
3096
6350
|
*
|
|
3097
6351
|
* @param params - Parameters for request
|
|
3098
6352
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
3099
6353
|
* @param callback - Optional callback that handles the response.
|
|
3100
6354
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
3101
6355
|
*/
|
|
3102
|
-
readFile(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Readfile, options: StreamMethodOptions):
|
|
3103
|
-
readFile(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Readfile, options?: MethodOptions):
|
|
6356
|
+
readFile(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Readfile, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
6357
|
+
readFile(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Readfile, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ReadFileResponse>>;
|
|
3104
6358
|
readFile(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Readfile, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
3105
6359
|
readFile(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Readfile, options: MethodOptions | BodyResponseCallback<Schema$ReadFileResponse>, callback: BodyResponseCallback<Schema$ReadFileResponse>): void;
|
|
3106
6360
|
readFile(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Readfile, callback: BodyResponseCallback<Schema$ReadFileResponse>): void;
|
|
3107
6361
|
readFile(callback: BodyResponseCallback<Schema$ReadFileResponse>): void;
|
|
3108
6362
|
/**
|
|
3109
6363
|
* Deletes a directory (inside a Workspace) and all of its contents.
|
|
6364
|
+
* @example
|
|
6365
|
+
* ```js
|
|
6366
|
+
* // Before running the sample:
|
|
6367
|
+
* // - Enable the API at:
|
|
6368
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
6369
|
+
* // - Login into gcloud by running:
|
|
6370
|
+
* // ```sh
|
|
6371
|
+
* // $ gcloud auth application-default login
|
|
6372
|
+
* // ```
|
|
6373
|
+
* // - Install the npm module by running:
|
|
6374
|
+
* // ```sh
|
|
6375
|
+
* // $ npm install googleapis
|
|
6376
|
+
* // ```
|
|
6377
|
+
*
|
|
6378
|
+
* const {google} = require('googleapis');
|
|
6379
|
+
* const dataform = google.dataform('v1beta1');
|
|
6380
|
+
*
|
|
6381
|
+
* async function main() {
|
|
6382
|
+
* const auth = new google.auth.GoogleAuth({
|
|
6383
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
6384
|
+
* scopes: [
|
|
6385
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
6386
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
6387
|
+
* ],
|
|
6388
|
+
* });
|
|
6389
|
+
*
|
|
6390
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
6391
|
+
* const authClient = await auth.getClient();
|
|
6392
|
+
* google.options({auth: authClient});
|
|
6393
|
+
*
|
|
6394
|
+
* // Do the magic
|
|
6395
|
+
* const res =
|
|
6396
|
+
* await dataform.projects.locations.repositories.workspaces.removeDirectory({
|
|
6397
|
+
* // Required. The workspace's name.
|
|
6398
|
+
* workspace:
|
|
6399
|
+
* 'projects/my-project/locations/my-location/repositories/my-repositorie/workspaces/my-workspace',
|
|
6400
|
+
*
|
|
6401
|
+
* // Request body metadata
|
|
6402
|
+
* requestBody: {
|
|
6403
|
+
* // request body parameters
|
|
6404
|
+
* // {
|
|
6405
|
+
* // "path": "my_path"
|
|
6406
|
+
* // }
|
|
6407
|
+
* },
|
|
6408
|
+
* });
|
|
6409
|
+
* console.log(res.data);
|
|
6410
|
+
*
|
|
6411
|
+
* // Example response
|
|
6412
|
+
* // {}
|
|
6413
|
+
* }
|
|
6414
|
+
*
|
|
6415
|
+
* main().catch(e => {
|
|
6416
|
+
* console.error(e);
|
|
6417
|
+
* throw e;
|
|
6418
|
+
* });
|
|
6419
|
+
*
|
|
6420
|
+
* ```
|
|
3110
6421
|
*
|
|
3111
6422
|
* @param params - Parameters for request
|
|
3112
6423
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
3113
6424
|
* @param callback - Optional callback that handles the response.
|
|
3114
6425
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
3115
6426
|
*/
|
|
3116
|
-
removeDirectory(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Removedirectory, options: StreamMethodOptions):
|
|
3117
|
-
removeDirectory(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Removedirectory, options?: MethodOptions):
|
|
6427
|
+
removeDirectory(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Removedirectory, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
6428
|
+
removeDirectory(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Removedirectory, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$RemoveDirectoryResponse>>;
|
|
3118
6429
|
removeDirectory(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Removedirectory, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
3119
6430
|
removeDirectory(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Removedirectory, options: MethodOptions | BodyResponseCallback<Schema$RemoveDirectoryResponse>, callback: BodyResponseCallback<Schema$RemoveDirectoryResponse>): void;
|
|
3120
6431
|
removeDirectory(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Removedirectory, callback: BodyResponseCallback<Schema$RemoveDirectoryResponse>): void;
|
|
3121
6432
|
removeDirectory(callback: BodyResponseCallback<Schema$RemoveDirectoryResponse>): void;
|
|
3122
6433
|
/**
|
|
3123
6434
|
* Deletes a file (inside a Workspace).
|
|
6435
|
+
* @example
|
|
6436
|
+
* ```js
|
|
6437
|
+
* // Before running the sample:
|
|
6438
|
+
* // - Enable the API at:
|
|
6439
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
6440
|
+
* // - Login into gcloud by running:
|
|
6441
|
+
* // ```sh
|
|
6442
|
+
* // $ gcloud auth application-default login
|
|
6443
|
+
* // ```
|
|
6444
|
+
* // - Install the npm module by running:
|
|
6445
|
+
* // ```sh
|
|
6446
|
+
* // $ npm install googleapis
|
|
6447
|
+
* // ```
|
|
6448
|
+
*
|
|
6449
|
+
* const {google} = require('googleapis');
|
|
6450
|
+
* const dataform = google.dataform('v1beta1');
|
|
6451
|
+
*
|
|
6452
|
+
* async function main() {
|
|
6453
|
+
* const auth = new google.auth.GoogleAuth({
|
|
6454
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
6455
|
+
* scopes: [
|
|
6456
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
6457
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
6458
|
+
* ],
|
|
6459
|
+
* });
|
|
6460
|
+
*
|
|
6461
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
6462
|
+
* const authClient = await auth.getClient();
|
|
6463
|
+
* google.options({auth: authClient});
|
|
6464
|
+
*
|
|
6465
|
+
* // Do the magic
|
|
6466
|
+
* const res =
|
|
6467
|
+
* await dataform.projects.locations.repositories.workspaces.removeFile({
|
|
6468
|
+
* // Required. The workspace's name.
|
|
6469
|
+
* workspace:
|
|
6470
|
+
* 'projects/my-project/locations/my-location/repositories/my-repositorie/workspaces/my-workspace',
|
|
6471
|
+
*
|
|
6472
|
+
* // Request body metadata
|
|
6473
|
+
* requestBody: {
|
|
6474
|
+
* // request body parameters
|
|
6475
|
+
* // {
|
|
6476
|
+
* // "path": "my_path"
|
|
6477
|
+
* // }
|
|
6478
|
+
* },
|
|
6479
|
+
* });
|
|
6480
|
+
* console.log(res.data);
|
|
6481
|
+
*
|
|
6482
|
+
* // Example response
|
|
6483
|
+
* // {}
|
|
6484
|
+
* }
|
|
6485
|
+
*
|
|
6486
|
+
* main().catch(e => {
|
|
6487
|
+
* console.error(e);
|
|
6488
|
+
* throw e;
|
|
6489
|
+
* });
|
|
6490
|
+
*
|
|
6491
|
+
* ```
|
|
3124
6492
|
*
|
|
3125
6493
|
* @param params - Parameters for request
|
|
3126
6494
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
3127
6495
|
* @param callback - Optional callback that handles the response.
|
|
3128
6496
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
3129
6497
|
*/
|
|
3130
|
-
removeFile(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Removefile, options: StreamMethodOptions):
|
|
3131
|
-
removeFile(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Removefile, options?: MethodOptions):
|
|
6498
|
+
removeFile(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Removefile, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
6499
|
+
removeFile(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Removefile, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$RemoveFileResponse>>;
|
|
3132
6500
|
removeFile(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Removefile, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
3133
6501
|
removeFile(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Removefile, options: MethodOptions | BodyResponseCallback<Schema$RemoveFileResponse>, callback: BodyResponseCallback<Schema$RemoveFileResponse>): void;
|
|
3134
6502
|
removeFile(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Removefile, callback: BodyResponseCallback<Schema$RemoveFileResponse>): void;
|
|
3135
6503
|
removeFile(callback: BodyResponseCallback<Schema$RemoveFileResponse>): void;
|
|
3136
6504
|
/**
|
|
3137
6505
|
* Performs a Git reset for uncommitted files in a Workspace.
|
|
6506
|
+
* @example
|
|
6507
|
+
* ```js
|
|
6508
|
+
* // Before running the sample:
|
|
6509
|
+
* // - Enable the API at:
|
|
6510
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
6511
|
+
* // - Login into gcloud by running:
|
|
6512
|
+
* // ```sh
|
|
6513
|
+
* // $ gcloud auth application-default login
|
|
6514
|
+
* // ```
|
|
6515
|
+
* // - Install the npm module by running:
|
|
6516
|
+
* // ```sh
|
|
6517
|
+
* // $ npm install googleapis
|
|
6518
|
+
* // ```
|
|
6519
|
+
*
|
|
6520
|
+
* const {google} = require('googleapis');
|
|
6521
|
+
* const dataform = google.dataform('v1beta1');
|
|
6522
|
+
*
|
|
6523
|
+
* async function main() {
|
|
6524
|
+
* const auth = new google.auth.GoogleAuth({
|
|
6525
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
6526
|
+
* scopes: [
|
|
6527
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
6528
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
6529
|
+
* ],
|
|
6530
|
+
* });
|
|
6531
|
+
*
|
|
6532
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
6533
|
+
* const authClient = await auth.getClient();
|
|
6534
|
+
* google.options({auth: authClient});
|
|
6535
|
+
*
|
|
6536
|
+
* // Do the magic
|
|
6537
|
+
* const res = await dataform.projects.locations.repositories.workspaces.reset({
|
|
6538
|
+
* // Required. The workspace's name.
|
|
6539
|
+
* name: 'projects/my-project/locations/my-location/repositories/my-repositorie/workspaces/my-workspace',
|
|
6540
|
+
*
|
|
6541
|
+
* // Request body metadata
|
|
6542
|
+
* requestBody: {
|
|
6543
|
+
* // request body parameters
|
|
6544
|
+
* // {
|
|
6545
|
+
* // "clean": false,
|
|
6546
|
+
* // "paths": []
|
|
6547
|
+
* // }
|
|
6548
|
+
* },
|
|
6549
|
+
* });
|
|
6550
|
+
* console.log(res.data);
|
|
6551
|
+
*
|
|
6552
|
+
* // Example response
|
|
6553
|
+
* // {}
|
|
6554
|
+
* }
|
|
6555
|
+
*
|
|
6556
|
+
* main().catch(e => {
|
|
6557
|
+
* console.error(e);
|
|
6558
|
+
* throw e;
|
|
6559
|
+
* });
|
|
6560
|
+
*
|
|
6561
|
+
* ```
|
|
3138
6562
|
*
|
|
3139
6563
|
* @param params - Parameters for request
|
|
3140
6564
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
3141
6565
|
* @param callback - Optional callback that handles the response.
|
|
3142
6566
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
3143
6567
|
*/
|
|
3144
|
-
reset(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Reset, options: StreamMethodOptions):
|
|
3145
|
-
reset(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Reset, options?: MethodOptions):
|
|
6568
|
+
reset(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Reset, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
6569
|
+
reset(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Reset, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$ResetWorkspaceChangesResponse>>;
|
|
3146
6570
|
reset(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Reset, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
3147
6571
|
reset(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Reset, options: MethodOptions | BodyResponseCallback<Schema$ResetWorkspaceChangesResponse>, callback: BodyResponseCallback<Schema$ResetWorkspaceChangesResponse>): void;
|
|
3148
6572
|
reset(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Reset, callback: BodyResponseCallback<Schema$ResetWorkspaceChangesResponse>): void;
|
|
3149
6573
|
reset(callback: BodyResponseCallback<Schema$ResetWorkspaceChangesResponse>): void;
|
|
3150
6574
|
/**
|
|
3151
6575
|
* Finds the contents of a given Workspace directory by filter.
|
|
6576
|
+
* @example
|
|
6577
|
+
* ```js
|
|
6578
|
+
* // Before running the sample:
|
|
6579
|
+
* // - Enable the API at:
|
|
6580
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
6581
|
+
* // - Login into gcloud by running:
|
|
6582
|
+
* // ```sh
|
|
6583
|
+
* // $ gcloud auth application-default login
|
|
6584
|
+
* // ```
|
|
6585
|
+
* // - Install the npm module by running:
|
|
6586
|
+
* // ```sh
|
|
6587
|
+
* // $ npm install googleapis
|
|
6588
|
+
* // ```
|
|
6589
|
+
*
|
|
6590
|
+
* const {google} = require('googleapis');
|
|
6591
|
+
* const dataform = google.dataform('v1beta1');
|
|
6592
|
+
*
|
|
6593
|
+
* async function main() {
|
|
6594
|
+
* const auth = new google.auth.GoogleAuth({
|
|
6595
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
6596
|
+
* scopes: [
|
|
6597
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
6598
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
6599
|
+
* ],
|
|
6600
|
+
* });
|
|
6601
|
+
*
|
|
6602
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
6603
|
+
* const authClient = await auth.getClient();
|
|
6604
|
+
* google.options({auth: authClient});
|
|
6605
|
+
*
|
|
6606
|
+
* // Do the magic
|
|
6607
|
+
* const res =
|
|
6608
|
+
* await dataform.projects.locations.repositories.workspaces.searchFiles({
|
|
6609
|
+
* // Optional. Optional filter for the returned list in filtering format. Filtering is only currently supported on the `path` field. See https://google.aip.dev/160 for details.
|
|
6610
|
+
* filter: 'placeholder-value',
|
|
6611
|
+
* // Optional. Maximum number of search results to return. The server may return fewer items than requested. If unspecified, the server will pick an appropriate default.
|
|
6612
|
+
* pageSize: 'placeholder-value',
|
|
6613
|
+
* // Optional. Page token received from a previous `SearchFilesRequest` call. Provide this to retrieve the subsequent page. When paginating, all other parameters provided to `SearchFilesRequest`, with the exception of `page_size`, must match the call that provided the page token.
|
|
6614
|
+
* pageToken: 'placeholder-value',
|
|
6615
|
+
* // Required. The workspace's name.
|
|
6616
|
+
* workspace:
|
|
6617
|
+
* 'projects/my-project/locations/my-location/repositories/my-repositorie/workspaces/my-workspace',
|
|
6618
|
+
* });
|
|
6619
|
+
* console.log(res.data);
|
|
6620
|
+
*
|
|
6621
|
+
* // Example response
|
|
6622
|
+
* // {
|
|
6623
|
+
* // "nextPageToken": "my_nextPageToken",
|
|
6624
|
+
* // "searchResults": []
|
|
6625
|
+
* // }
|
|
6626
|
+
* }
|
|
6627
|
+
*
|
|
6628
|
+
* main().catch(e => {
|
|
6629
|
+
* console.error(e);
|
|
6630
|
+
* throw e;
|
|
6631
|
+
* });
|
|
6632
|
+
*
|
|
6633
|
+
* ```
|
|
3152
6634
|
*
|
|
3153
6635
|
* @param params - Parameters for request
|
|
3154
6636
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
3155
6637
|
* @param callback - Optional callback that handles the response.
|
|
3156
6638
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
3157
6639
|
*/
|
|
3158
|
-
searchFiles(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Searchfiles, options: StreamMethodOptions):
|
|
3159
|
-
searchFiles(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Searchfiles, options?: MethodOptions):
|
|
6640
|
+
searchFiles(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Searchfiles, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
6641
|
+
searchFiles(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Searchfiles, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$SearchFilesResponse>>;
|
|
3160
6642
|
searchFiles(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Searchfiles, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
3161
6643
|
searchFiles(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Searchfiles, options: MethodOptions | BodyResponseCallback<Schema$SearchFilesResponse>, callback: BodyResponseCallback<Schema$SearchFilesResponse>): void;
|
|
3162
6644
|
searchFiles(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Searchfiles, callback: BodyResponseCallback<Schema$SearchFilesResponse>): void;
|
|
3163
6645
|
searchFiles(callback: BodyResponseCallback<Schema$SearchFilesResponse>): void;
|
|
3164
6646
|
/**
|
|
3165
6647
|
* Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.
|
|
6648
|
+
* @example
|
|
6649
|
+
* ```js
|
|
6650
|
+
* // Before running the sample:
|
|
6651
|
+
* // - Enable the API at:
|
|
6652
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
6653
|
+
* // - Login into gcloud by running:
|
|
6654
|
+
* // ```sh
|
|
6655
|
+
* // $ gcloud auth application-default login
|
|
6656
|
+
* // ```
|
|
6657
|
+
* // - Install the npm module by running:
|
|
6658
|
+
* // ```sh
|
|
6659
|
+
* // $ npm install googleapis
|
|
6660
|
+
* // ```
|
|
6661
|
+
*
|
|
6662
|
+
* const {google} = require('googleapis');
|
|
6663
|
+
* const dataform = google.dataform('v1beta1');
|
|
6664
|
+
*
|
|
6665
|
+
* async function main() {
|
|
6666
|
+
* const auth = new google.auth.GoogleAuth({
|
|
6667
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
6668
|
+
* scopes: [
|
|
6669
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
6670
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
6671
|
+
* ],
|
|
6672
|
+
* });
|
|
6673
|
+
*
|
|
6674
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
6675
|
+
* const authClient = await auth.getClient();
|
|
6676
|
+
* google.options({auth: authClient});
|
|
6677
|
+
*
|
|
6678
|
+
* // Do the magic
|
|
6679
|
+
* const res =
|
|
6680
|
+
* await dataform.projects.locations.repositories.workspaces.setIamPolicy({
|
|
6681
|
+
* // REQUIRED: The resource for which the policy is being specified. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.
|
|
6682
|
+
* resource:
|
|
6683
|
+
* 'projects/my-project/locations/my-location/repositories/my-repositorie/workspaces/my-workspace',
|
|
6684
|
+
*
|
|
6685
|
+
* // Request body metadata
|
|
6686
|
+
* requestBody: {
|
|
6687
|
+
* // request body parameters
|
|
6688
|
+
* // {
|
|
6689
|
+
* // "policy": {}
|
|
6690
|
+
* // }
|
|
6691
|
+
* },
|
|
6692
|
+
* });
|
|
6693
|
+
* console.log(res.data);
|
|
6694
|
+
*
|
|
6695
|
+
* // Example response
|
|
6696
|
+
* // {
|
|
6697
|
+
* // "bindings": [],
|
|
6698
|
+
* // "etag": "my_etag",
|
|
6699
|
+
* // "version": 0
|
|
6700
|
+
* // }
|
|
6701
|
+
* }
|
|
6702
|
+
*
|
|
6703
|
+
* main().catch(e => {
|
|
6704
|
+
* console.error(e);
|
|
6705
|
+
* throw e;
|
|
6706
|
+
* });
|
|
6707
|
+
*
|
|
6708
|
+
* ```
|
|
3166
6709
|
*
|
|
3167
6710
|
* @param params - Parameters for request
|
|
3168
6711
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
3169
6712
|
* @param callback - Optional callback that handles the response.
|
|
3170
6713
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
3171
6714
|
*/
|
|
3172
|
-
setIamPolicy(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Setiampolicy, options: StreamMethodOptions):
|
|
3173
|
-
setIamPolicy(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Setiampolicy, options?: MethodOptions):
|
|
6715
|
+
setIamPolicy(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Setiampolicy, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
6716
|
+
setIamPolicy(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Setiampolicy, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$Policy>>;
|
|
3174
6717
|
setIamPolicy(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Setiampolicy, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
3175
6718
|
setIamPolicy(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Setiampolicy, options: MethodOptions | BodyResponseCallback<Schema$Policy>, callback: BodyResponseCallback<Schema$Policy>): void;
|
|
3176
6719
|
setIamPolicy(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Setiampolicy, callback: BodyResponseCallback<Schema$Policy>): void;
|
|
3177
6720
|
setIamPolicy(callback: BodyResponseCallback<Schema$Policy>): void;
|
|
3178
6721
|
/**
|
|
3179
6722
|
* Returns permissions that a caller has on the specified resource. If the resource does not exist, this will return an empty set of permissions, not a `NOT_FOUND` error. Note: This operation is designed to be used for building permission-aware UIs and command-line tools, not for authorization checking. This operation may "fail open" without warning.
|
|
6723
|
+
* @example
|
|
6724
|
+
* ```js
|
|
6725
|
+
* // Before running the sample:
|
|
6726
|
+
* // - Enable the API at:
|
|
6727
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
6728
|
+
* // - Login into gcloud by running:
|
|
6729
|
+
* // ```sh
|
|
6730
|
+
* // $ gcloud auth application-default login
|
|
6731
|
+
* // ```
|
|
6732
|
+
* // - Install the npm module by running:
|
|
6733
|
+
* // ```sh
|
|
6734
|
+
* // $ npm install googleapis
|
|
6735
|
+
* // ```
|
|
6736
|
+
*
|
|
6737
|
+
* const {google} = require('googleapis');
|
|
6738
|
+
* const dataform = google.dataform('v1beta1');
|
|
6739
|
+
*
|
|
6740
|
+
* async function main() {
|
|
6741
|
+
* const auth = new google.auth.GoogleAuth({
|
|
6742
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
6743
|
+
* scopes: [
|
|
6744
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
6745
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
6746
|
+
* ],
|
|
6747
|
+
* });
|
|
6748
|
+
*
|
|
6749
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
6750
|
+
* const authClient = await auth.getClient();
|
|
6751
|
+
* google.options({auth: authClient});
|
|
6752
|
+
*
|
|
6753
|
+
* // Do the magic
|
|
6754
|
+
* const res =
|
|
6755
|
+
* await dataform.projects.locations.repositories.workspaces.testIamPermissions(
|
|
6756
|
+
* {
|
|
6757
|
+
* // REQUIRED: The resource for which the policy detail is being requested. See [Resource names](https://cloud.google.com/apis/design/resource_names) for the appropriate value for this field.
|
|
6758
|
+
* resource:
|
|
6759
|
+
* 'projects/my-project/locations/my-location/repositories/my-repositorie/workspaces/my-workspace',
|
|
6760
|
+
*
|
|
6761
|
+
* // Request body metadata
|
|
6762
|
+
* requestBody: {
|
|
6763
|
+
* // request body parameters
|
|
6764
|
+
* // {
|
|
6765
|
+
* // "permissions": []
|
|
6766
|
+
* // }
|
|
6767
|
+
* },
|
|
6768
|
+
* },
|
|
6769
|
+
* );
|
|
6770
|
+
* console.log(res.data);
|
|
6771
|
+
*
|
|
6772
|
+
* // Example response
|
|
6773
|
+
* // {
|
|
6774
|
+
* // "permissions": []
|
|
6775
|
+
* // }
|
|
6776
|
+
* }
|
|
6777
|
+
*
|
|
6778
|
+
* main().catch(e => {
|
|
6779
|
+
* console.error(e);
|
|
6780
|
+
* throw e;
|
|
6781
|
+
* });
|
|
6782
|
+
*
|
|
6783
|
+
* ```
|
|
3180
6784
|
*
|
|
3181
6785
|
* @param params - Parameters for request
|
|
3182
6786
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
3183
6787
|
* @param callback - Optional callback that handles the response.
|
|
3184
6788
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
3185
6789
|
*/
|
|
3186
|
-
testIamPermissions(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Testiampermissions, options: StreamMethodOptions):
|
|
3187
|
-
testIamPermissions(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Testiampermissions, options?: MethodOptions):
|
|
6790
|
+
testIamPermissions(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Testiampermissions, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
6791
|
+
testIamPermissions(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Testiampermissions, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$TestIamPermissionsResponse>>;
|
|
3188
6792
|
testIamPermissions(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Testiampermissions, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
3189
6793
|
testIamPermissions(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Testiampermissions, options: MethodOptions | BodyResponseCallback<Schema$TestIamPermissionsResponse>, callback: BodyResponseCallback<Schema$TestIamPermissionsResponse>): void;
|
|
3190
6794
|
testIamPermissions(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Testiampermissions, callback: BodyResponseCallback<Schema$TestIamPermissionsResponse>): void;
|
|
3191
6795
|
testIamPermissions(callback: BodyResponseCallback<Schema$TestIamPermissionsResponse>): void;
|
|
3192
6796
|
/**
|
|
3193
6797
|
* Writes to a file (inside a Workspace).
|
|
6798
|
+
* @example
|
|
6799
|
+
* ```js
|
|
6800
|
+
* // Before running the sample:
|
|
6801
|
+
* // - Enable the API at:
|
|
6802
|
+
* // https://console.developers.google.com/apis/api/dataform.googleapis.com
|
|
6803
|
+
* // - Login into gcloud by running:
|
|
6804
|
+
* // ```sh
|
|
6805
|
+
* // $ gcloud auth application-default login
|
|
6806
|
+
* // ```
|
|
6807
|
+
* // - Install the npm module by running:
|
|
6808
|
+
* // ```sh
|
|
6809
|
+
* // $ npm install googleapis
|
|
6810
|
+
* // ```
|
|
6811
|
+
*
|
|
6812
|
+
* const {google} = require('googleapis');
|
|
6813
|
+
* const dataform = google.dataform('v1beta1');
|
|
6814
|
+
*
|
|
6815
|
+
* async function main() {
|
|
6816
|
+
* const auth = new google.auth.GoogleAuth({
|
|
6817
|
+
* // Scopes can be specified either as an array or as a single, space-delimited string.
|
|
6818
|
+
* scopes: [
|
|
6819
|
+
* 'https://www.googleapis.com/auth/bigquery',
|
|
6820
|
+
* 'https://www.googleapis.com/auth/cloud-platform',
|
|
6821
|
+
* ],
|
|
6822
|
+
* });
|
|
6823
|
+
*
|
|
6824
|
+
* // Acquire an auth client, and bind it to all future calls
|
|
6825
|
+
* const authClient = await auth.getClient();
|
|
6826
|
+
* google.options({auth: authClient});
|
|
6827
|
+
*
|
|
6828
|
+
* // Do the magic
|
|
6829
|
+
* const res =
|
|
6830
|
+
* await dataform.projects.locations.repositories.workspaces.writeFile({
|
|
6831
|
+
* // Required. The workspace's name.
|
|
6832
|
+
* workspace:
|
|
6833
|
+
* 'projects/my-project/locations/my-location/repositories/my-repositorie/workspaces/my-workspace',
|
|
6834
|
+
*
|
|
6835
|
+
* // Request body metadata
|
|
6836
|
+
* requestBody: {
|
|
6837
|
+
* // request body parameters
|
|
6838
|
+
* // {
|
|
6839
|
+
* // "contents": "my_contents",
|
|
6840
|
+
* // "path": "my_path"
|
|
6841
|
+
* // }
|
|
6842
|
+
* },
|
|
6843
|
+
* });
|
|
6844
|
+
* console.log(res.data);
|
|
6845
|
+
*
|
|
6846
|
+
* // Example response
|
|
6847
|
+
* // {}
|
|
6848
|
+
* }
|
|
6849
|
+
*
|
|
6850
|
+
* main().catch(e => {
|
|
6851
|
+
* console.error(e);
|
|
6852
|
+
* throw e;
|
|
6853
|
+
* });
|
|
6854
|
+
*
|
|
6855
|
+
* ```
|
|
3194
6856
|
*
|
|
3195
6857
|
* @param params - Parameters for request
|
|
3196
6858
|
* @param options - Optionally override request options, such as `url`, `method`, and `encoding`.
|
|
3197
6859
|
* @param callback - Optional callback that handles the response.
|
|
3198
6860
|
* @returns A promise if used with async/await, or void if used with a callback.
|
|
3199
6861
|
*/
|
|
3200
|
-
writeFile(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Writefile, options: StreamMethodOptions):
|
|
3201
|
-
writeFile(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Writefile, options?: MethodOptions):
|
|
6862
|
+
writeFile(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Writefile, options: StreamMethodOptions): Promise<GaxiosResponseWithHTTP2<Readable>>;
|
|
6863
|
+
writeFile(params?: Params$Resource$Projects$Locations$Repositories$Workspaces$Writefile, options?: MethodOptions): Promise<GaxiosResponseWithHTTP2<Schema$WriteFileResponse>>;
|
|
3202
6864
|
writeFile(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Writefile, options: StreamMethodOptions | BodyResponseCallback<Readable>, callback: BodyResponseCallback<Readable>): void;
|
|
3203
6865
|
writeFile(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Writefile, options: MethodOptions | BodyResponseCallback<Schema$WriteFileResponse>, callback: BodyResponseCallback<Schema$WriteFileResponse>): void;
|
|
3204
6866
|
writeFile(params: Params$Resource$Projects$Locations$Repositories$Workspaces$Writefile, callback: BodyResponseCallback<Schema$WriteFileResponse>): void;
|