0% found this document useful (0 votes)
90 views

Gapi Dart

The document provides type definitions for the Google API client library. It defines classes like GoogleApiOAuth2TokenObject that represent an OAuth 2.0 token and associated data. It also defines functions for authenticating and making requests to Google APIs using the client library.
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
90 views

Gapi Dart

The document provides type definitions for the Google API client library. It defines classes like GoogleApiOAuth2TokenObject that represent an OAuth 2.0 token and associated data. It also defines functions for authenticating and making requests to Google APIs using the client library.
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 8

// Copyright 2019 The Chromium Authors. All rights reserved.

// Use of this source code is governed by a BSD-style license that can be


// found in the LICENSE file.

@JS()
library gapi;

import "package:js/js.dart";
import "package:js/js_util.dart" show promiseToFuture;

/// Type definitions for Google API Client


/// Project: https://github.com/google/google-api-javascript-client
/// Definitions by: Frank M <https://github.com/sgtfrankieboy>, grant <https://g
ithub.com/grant>
/// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
/// TypeScript Version: 2.3

/// The OAuth 2.0 token object represents the OAuth 2.0 token and any associated
data.
@anonymous
@JS()
abstract class GoogleApiOAuth2TokenObject {
/// The OAuth 2.0 token. Only present in successful responses
external String get access_token;
external set access_token(String v);

/// Details about the error. Only present in error responses


external String get error;
external set error(String v);

/// The duration, in seconds, the token is valid for. Only present in successf
ul responses
external String get expires_in;
external set expires_in(String v);
external GoogleApiOAuth2TokenSessionState get session_state;
external set session_state(GoogleApiOAuth2TokenSessionState v);

/// The Google API scopes related to this token


external String get state;
external set state(String v);
external factory GoogleApiOAuth2TokenObject(
{String access_token,
String error,
String expires_in,
GoogleApiOAuth2TokenSessionState session_state,
String state});
}

@anonymous
@JS()
abstract class GoogleApiOAuth2TokenSessionState {
external dynamic /*{
authuser: string,
}*/
get extraQueryParams;
external set extraQueryParams(
dynamic
/*{
authuser: string,
}*/
v);
external factory GoogleApiOAuth2TokenSessionState(
{dynamic
/*{
authuser: string,
}*/
extraQueryParams});
}

/// Fix for #8215


/// https://github.com/DefinitelyTyped/DefinitelyTyped/issues/8215
/// Usage example:
/// https://developers.google.com/identity/sign-in/web/session-state

// Module gapi
typedef void LoadCallback(
[dynamic args1,
dynamic args2,
dynamic args3,
dynamic args4,
dynamic args5]);

@anonymous
@JS()
abstract class LoadConfig {
external LoadCallback get callback;
external set callback(LoadCallback v);
external Function get onerror;
external set onerror(Function v);
external num get timeout;
external set timeout(num v);
external Function get ontimeout;
external set ontimeout(Function v);
external factory LoadConfig(
{LoadCallback callback,
Function onerror,
num timeout,
Function ontimeout});
}

/*type CallbackOrConfig = LoadConfig | LoadCallback;*/


/// Pragmatically initialize gapi class member.
/// Reference: https://developers.google.com/api-client-library/javascript/refer
ence/referencedocs#gapiloadlibraries-callbackorconfig
@JS("gapi.load")
external void load(
String apiName, dynamic /*LoadConfig|LoadCallback*/ callback);
// End module gapi

// Module gapi.auth
/// Initiates the OAuth 2.0 authorization process. The browser displays a popup
window prompting the user authenticate and authorize. After the user authorizes,
the popup closes and the callback function fires.
@JS("gapi.auth.authorize")
external void authorize(
dynamic
/*{
/**
* The application's client ID.
*/
client_id?: string;
/**
* If true, then login uses "immediate mode", which means that the token
is refreshed behind the scenes, and no UI is shown to the user.
*/
immediate?: boolean;
/**
* The OAuth 2.0 response type property. Default: token
*/
response_type?: string;
/**
* The auth scope or scopes to authorize. Auth scopes for individual API
s can be found in their documentation.
*/
scope?: any;
/**
* The user to sign in as. -1 to toggle a multi-account chooser, 0 to de
fault to the user's current account, and 1 to automatically sign in if the user
is signed into Google Plus.
*/
authuser?: number;
}*/
params,
dynamic callback(GoogleApiOAuth2TokenObject token));

/// Initializes the authorization feature. Call this when the client loads to pr
event popup blockers from blocking the auth window on gapi.auth.authorize calls.
@JS("gapi.auth.init")
external void init(dynamic callback());

/// Retrieves the OAuth 2.0 token for the application.


@JS("gapi.auth.getToken")
external GoogleApiOAuth2TokenObject getToken();

/// Sets the OAuth 2.0 token for the application.


@JS("gapi.auth.setToken")
external void setToken(GoogleApiOAuth2TokenObject token);

/// Initiates the client-side Google+ Sign-In OAuth 2.0 flow.


/// When the method is called, the OAuth 2.0 authorization dialog is displayed t
o the user and when they accept, the callback function is called.
@JS("gapi.auth.signIn")
external void signIn(
dynamic
/*{
/**
* Your OAuth 2.0 client ID that you obtained from the Google Developers
Console.
*/
clientid?: string;
/**
* Directs the sign-in button to store user and session information in a
session cookie and HTML5 session storage on the user's client for the purpose o
f minimizing HTTP traffic and distinguishing between multiple Google accounts a
user might be signed into.
*/
cookiepolicy?: string;
/**
* A function in the global namespace, which is called when the sign-in
button is rendered and also called after a sign-in flow completes.
*/
callback?: () => void;
/**
* If true, all previously granted scopes remain granted in each increme
ntal request, for incremental authorization. The default value true is correct f
or most use cases; use false only if employing delegated auth, where you pass th
e bearer token to a less-trusted component with lower programmatic authority.
*/
includegrantedscopes?: boolean;
/**
* If your app will write moments, list the full URI of the types of mom
ents that you intend to write.
*/
requestvisibleactions?: any;
/**
* The OAuth 2.0 scopes for the APIs that you would like to use as a spa
ce-delimited list.
*/
scope?: any;
/**
* If you have an Android app, you can drive automatic Android downloads
from your web sign-in flow.
*/
apppackagename?: string;
}*/
params);

/// Signs a user out of your app without logging the user out of Google. This me
thod will only work when the user is signed in with Google+ Sign-In.
@JS("gapi.auth.signOut")
external void signOut();
// End module gapi.auth

// Module gapi.client
@anonymous
@JS()
abstract class RequestOptions {
/// The URL to handle the request
external String get path;
external set path(String v);

/// The HTTP request method to use. Default is GET


external String get method;
external set method(String v);

/// URL params in key-value pair form


external dynamic get params;
external set params(dynamic v);

/// Additional HTTP request headers


external dynamic get headers;
external set headers(dynamic v);

/// The HTTP request body (applies to PUT or POST).


external dynamic get body;
external set body(dynamic v);

/// If supplied, the request is executed immediately and no gapi.client.HttpRe


quest object is returned
external dynamic Function() get callback;
external set callback(dynamic Function() v);
external factory RequestOptions(
{String path,
String method,
dynamic params,
dynamic headers,
dynamic body,
dynamic Function() callback});
}

@anonymous
@JS()
abstract class _RequestOptions {
@JS("gapi.client.init")
external Promise<void> client_init(
dynamic
/*{
/**
* The API Key to use.
*/
apiKey?: string;
/**
* An array of discovery doc URLs or discovery doc JSON objects.
*/
discoveryDocs?: string[];
/**
* The app's client ID, found and created in the Google Developers Conso
le.
*/
clientId?: string;
/**
* The scopes to request, as a space-delimited string.
*/
scope?: string,

hosted_domain?: string;
}*/
args);
}

extension RequestOptionsExtensions on RequestOptions {}

@anonymous
@JS()
abstract class TokenObject {
/// The access token to use in requests.
external String get access_token;
external set access_token(String v);
external factory TokenObject({String access_token});
}

/// Creates a HTTP request for making RESTful requests.


/// An object encapsulating the various arguments for this method.
@JS("gapi.client.request")
external HttpRequest<dynamic> request(RequestOptions args);

/// Creates an RPC Request directly. The method name and version identify the me
thod to be executed and the RPC params are provided upon RPC creation.
@JS("gapi.client.rpcRequest")
external RpcRequest rpcRequest(String method,
[String version, dynamic rpcParams]);

/// Sets the API key for the application.


@JS("gapi.client.setApiKey")
external void setApiKey(String apiKey);

/// Retrieves the OAuth 2.0 token for the application.


@JS("gapi.client.getToken")
external GoogleApiOAuth2TokenObject client_getToken();
/// Sets the authentication token to use in requests.
/// Reference: https://developers.google.com/api-client-library/javascript/refer
ence/referencedocs#gapiclientsettokentokenobject
@JS("gapi.client.setToken")
external void client_setToken(TokenObject /*TokenObject|Null*/ token);

@anonymous
@JS()
abstract class HttpRequestFulfilled<T> {
external T get result;
external set result(T v);
external String get body;
external set body(String v);
external List<dynamic> get headers;
external set headers(List<dynamic> v);
external num get status;
external set status(num v);
external String get statusText;
external set statusText(String v);
external factory HttpRequestFulfilled(
{T result,
String body,
List<dynamic> headers,
num status,
String statusText});
}

@anonymous
@JS()
abstract class _HttpRequestFulfilled<T> {
/*external Promise<void> client_load(String name, String version);*/
/*external void client_load(String name, String version, dynamic callback(),
[String url]);
*/
@JS("gapi.client.load")
external dynamic /*Promise<void>|void*/ client_load(
String name, String version,
[dynamic callback(), String url]);
}

extension HttpRequestFulfilledExtensions<T> on HttpRequestFulfilled<T> {}

@anonymous
@JS()
abstract class HttpRequestRejected {
external dynamic /*dynamic|bool*/ get result;
external set result(dynamic /*dynamic|bool*/ v);
external String get body;
external set body(String v);
external List<dynamic> get headers;
external set headers(List<dynamic> v);
external num get status;
external set status(num v);
external String get statusText;
external set statusText(String v);
external factory HttpRequestRejected(
{dynamic /*dynamic|bool*/ result,
String body,
List<dynamic> headers,
num status,
String statusText});
}
/// HttpRequest supports promises.
/// See Google API Client JavaScript Using Promises https://developers.google.co
m/api-client-library/javascript/features/promises
@JS("gapi.client.HttpRequestPromise")
class HttpRequestPromise<T> {}

@JS("gapi.client.HttpRequestPromise")
abstract class _HttpRequestPromise<T> {
/// Taken and adapted from https://github.com/Microsoft/TypeScript/blob/v2.3.1
/lib/lib.es5.d.ts#L1343
external Promise<dynamic /*TResult1|TResult2*/ > then/*<TResult1, TResult2>*/(
[dynamic /*TResult1|PromiseLike<TResult1> Function(HttpRequestFulfilled<T>
)|dynamic|Null*/ onfulfilled,
dynamic /*TResult2|PromiseLike<TResult2> Function(HttpRequestRejected)|dyn
amic|Null*/ onrejected,
dynamic opt_context]);
}

extension HttpRequestPromiseExtensions<T> on HttpRequestPromise<T> {


Future<dynamic /*TResult1|TResult2*/ > then(
[dynamic /*TResult1|PromiseLike<TResult1> Function(HttpRequestFulfilled<T>
)|dynamic|Null*/ onfulfilled,
dynamic /*TResult2|PromiseLike<TResult2> Function(HttpRequestRejected)|dyn
amic|Null*/ onrejected,
dynamic opt_context]) {
final Object t = this;
final _HttpRequestPromise<T> tt = t;
return promiseToFuture(tt.then(onfulfilled, onrejected, opt_context));
}
}

/// An object encapsulating an HTTP request. This object is not instantiated dir
ectly, rather it is returned by gapi.client.request.
@JS("gapi.client.HttpRequest")
class HttpRequest<T> extends HttpRequestPromise<T> {
/// Executes the request and runs the supplied callback on response.
external void execute(
dynamic callback(

/// contains the response parsed as JSON. If the response is not JSON,
this field will be false.
T jsonResp,

/// is the HTTP response. It is JSON, and can be parsed to an object


dynamic
/*{
body: string;
headers: any[];
status: number;
statusText: string;
}*/
rawResp));
}

/// Represents an HTTP Batch operation. Individual HTTP requests are added with
the add method and the batch is executed using execute.
@JS("gapi.client.HttpBatch")
class HttpBatch {
/// Adds a gapi.client.HttpRequest to the batch.
external void add(HttpRequest<dynamic> httpRequest,
[dynamic
/*{
/**
* Identifies the response for this request in the map of batch resp
onses. If one is not provided, the system generates a random ID.
*/
id: string;
callback: (
/**
* is the response for this request only. Its format is defined
by the API method being called.
*/
individualResponse: any,
/**
* is the raw batch ID-response map as a string. It contains all
responses to all requests in the batch.
*/
rawBatchResponse: any
) => any
}*/
opt_params]);

/// Executes all requests in the batch. The supplied callback is executed on s
uccess or failure.
external void execute(
dynamic callback(

/// is an ID-response map of each requests response.


dynamic responseMap,

/// is the same response, but as an unparsed JSON-string.


String rawBatchResponse));
}

/// Similar to gapi.client.HttpRequest except this object encapsulates requests


generated by registered methods.
@JS("gapi.client.RpcRequest")
class RpcRequest {
/// Executes the request and runs the supplied callback with the response.
external void callback(
void callback(

/// contains the response parsed as JSON. If the response is not JSON,
this field will be false.
dynamic jsonResp,

/// is the same as jsonResp, except it is a raw string that has not be
en parsed. It is typically used when the response is not JSON.
String rawResp));
}

// End module gapi.client


@JS()
abstract class Promise<T> {
external factory Promise(
void executor(void resolve(T result), Function reject));
external Promise then(void onFulfilled(T result), [Function onRejected]);
}

You might also like