tra-analysis/website/functions/node_modules/firebase-functions/lib/cloud-functions.d.ts

/// <reference types="express" />
import { Request, Response } from 'express';
import { DeploymentOptions } from './function-builder';
export { Request, Response };
/** The context in which an event occurred.
 * An EventContext describes:
 * - The time an event occurred.
 * - A unique identifier of the event.
 * - The resource on which the event occurred, if applicable.
 * - Authorization of the request that triggered the event, if applicable and available.
 */
export interface EventContext {
    /** ID of the event */
    eventId: string;
    /** Timestamp for when the event occured (ISO string) */
    timestamp: string;
    /** Type of event */
    eventType: string;
    /** Resource that triggered the event */
    resource: Resource;
    /** Key-value pairs that represent the values of wildcards in a database reference */
    params: {
        [option: string]: any;
    };
    /** Type of authentication for the triggering action, valid value are: 'ADMIN', 'USER',
     * 'UNAUTHENTICATED'. Only available for database functions.
     */
    authType?: 'ADMIN' | 'USER' | 'UNAUTHENTICATED';
    /** Firebase auth variable for the user whose action triggered the function. Field will be
     * null for unauthenticated users, and will not exist for admin users. Only available
     * for database functions.
     */
    auth?: {
        uid: string;
        token: object;
    };
}
/** Change describes a change of state - "before" represents the state prior
 * to the event, "after" represents the state after the event.
 */
export declare class Change<T> {
    before: T;
    after: T;
    constructor(before?: T, after?: T);
}
/** ChangeJson is the JSON format used to construct a Change object. */
export interface ChangeJson {
    /** Key-value pairs representing state of data before the change.
     * If `fieldMask` is set, then only fields that changed are present in `before`.
     */
    before?: any;
    /** Key-value pairs representing state of data after the change. */
    after?: any;
    /** Comma-separated string that represents names of field that changed. */
    fieldMask?: string;
}
export declare namespace Change {
    /** Factory method for creating a Change from a `before` object and an `after` object. */
    function fromObjects<T>(before: T, after: T): Change<T>;
    /** Factory method for creating a Change from a JSON and an optional customizer function to be
     * applied to both the `before` and the `after` fields.
     */
    function fromJSON<T>(json: ChangeJson, customizer?: (x: any) => T): Change<T>;
}
/** Resource is a standard format for defining a resource (google.rpc.context.AttributeContext.Resource).
 * In Cloud Functions, it is the resource that triggered the function - such as a storage bucket.
 */
export interface Resource {
    service: string;
    name: string;
    type?: string;
    labels?: {
        [tag: string]: string;
    };
}
/** TriggerAnnotated is used internally by the firebase CLI to understand what type of Cloud Function to deploy. */
export interface TriggerAnnotated {
    __trigger: {
        httpsTrigger?: {};
        eventTrigger?: {
            eventType: string;
            resource: string;
            service: string;
        };
        labels?: {
            [key: string]: string;
        };
        regions?: string[];
        timeout?: string;
        availableMemoryMb?: number;
    };
}
/** A Runnable has a `run` method which directly invokes the user-defined function - useful for unit testing. */
export interface Runnable<T> {
    run: (data: T, context: any) => PromiseLike<any> | any;
}
/**
 * An HttpsFunction is both an object that exports its trigger definitions at __trigger and
 * can be called as a function that takes an express.js Request and Response object.
 */
export declare type HttpsFunction = TriggerAnnotated & ((req: Request, resp: Response) => void);
/**
 * A CloudFunction is both an object that exports its trigger definitions at __trigger and
 * can be called as a function using the raw JS API for Google Cloud Functions.
 */
export declare type CloudFunction<T> = Runnable<T> & TriggerAnnotated & ((input: any, context?: any) => PromiseLike<any> | any);
export declare function optsToTrigger(opts: DeploymentOptions): any;