import * as pulumi from "@pulumi/pulumi";
import * as express from "express";
import * as cloudfunctions from ".";
import * as storage from "../storage";
import * as inputs from "../types/input";
/**
 * Google Cloud Functions uses this parameter to provide details of your Function's execution. For
 * more information, see https://cloud.google.com/functions/docs/writing/background#function_parameters
 */
export interface Context {
    /** A unique ID for the event. For example: "70172329041928". */
    eventId: string;
    /** The date/time this event was created. For example: "2018-04-09T07:56:12.975Z". */
    timestamp: string;
    /** The type of the event. For example: "google.pubsub.topic.publish". */
    eventType: string;
    /** The resource that emitted the event. See derived contexts for more specific information
     * about the shape of this property. */
    resource: any;
}
/**
 * Callback is the signature for an Google Cloud Function entrypoint.
 *
 * [data] is the data passed in by specific services calling the Function (like storage, or pubsub).
 * The shape of it will be specific to individual services.
 *
 * [context] Cloud Functions uses this parameter to provide details of your Function's execution.
 * For more information, see
 * https://cloud.google.com/functions/docs/writing/background#function_parameters
 *
 * [callback] A callback to signal completion of the function's execution. Follows the "errback"
 * convention, which interprets the first argument as an error.
 *
 * You must signal when background functions have completed. Otherwise, your function can continue
 * to run and be forcibly terminated by the system. You can signal function completion by:
 *
 * 1. Invoking the callback argument,
 * 2. Returning a Promise,
 * 3. Wrapping your function using the async keyword (which causes your function to implicitly
 *    return a Promise), or
 * 4. Returning a value.
 *
 * If invoking the callback argument or synchronously returning a value, ensure that all
 * asynchronous processes have completed first. If returning a Promise, Cloud Functions ensures that
 * the Promise is settled before terminating.
 */
export type Callback<D, C extends Context, R> = (data: D, context: C, callback: (error?: any, result?: R) => void) => Promise<R> | void;
/**
 * CallbackFactory is the signature for a function that will be called once to produce the
 * entrypoint function that GCP Cloud Function will invoke.  It can be used to initialize expensive
 * state once that can then be used across all invocations of the Function (as long as the Function
 * is using the same warm node instance).
 */
export type CallbackFactory<D, C extends Context, R> = () => Callback<D, C, R>;
/**
 * Describes the policy in case of function's execution failure. If empty, then defaults to ignoring
 * failures (i.e. not retrying them).
 */
export interface FailurePolicy {
    /**
     * Whether the function should be retried on failure.
     *
     * If true, a function execution will be retried on any failure. A failed execution will be
     * retried up to 7 days with an exponential backoff (capped at 10 seconds). Retried execution is
     * charged as any other execution.
     */
    retry: pulumi.Input<boolean>;
}
/**
 * A CallbackFunction is a special type of gcp.cloudfunctions.Function that can be created out of an
 * actual JavaScript function instance.  The function instance will be analyzed and packaged up
 * (including dependencies) into a form that can be used by Cloud Functions.  See
 * https://github.com/pulumi/docs/blob/master/reference/serializing-functions.md for additional
 * details on this process.
 *
 * Note: CallbackFunctions create Google Cloud Functions that uses the [nodejs8] runtime.
 * Importantly, calls follow the `(data, context) => ...` form, not the `(event, callback) => ...`
 * form that is used with the [nodejs6] runtime.  This also adds support for asynchronous functions
 * as well. See
 * https://cloud.google.com/functions/docs/writing/background#functions_background_parameters-node8
 * for more details.
 */
export declare class CallbackFunction extends pulumi.ComponentResource {
    /**
     * Bucket and BucketObject storing all the files that comprise the Function.  The contents of
     * these files will be generated automatically from the JavaScript callback function passed in
     * as well as the package.json file for your pulumi app.
     */
    readonly bucket: storage.Bucket;
    readonly bucketObject: storage.BucketObject;
    /** Underlying raw resource for the Function that is created. */
    readonly function: cloudfunctions.Function;
    constructor(name: string, args: CallbackFunctionArgs, opts?: pulumi.ComponentResourceOptions);
}
/**
 * An http-triggered Cloud-Function that, when invoked, will execute the code supplied by a
 * user-provided JavaScript-Function.  To handle HTTP, Cloud Functions uses Express 4.16.3.
 *
 * You invoke HTTP functions from standard HTTP requests. These HTTP requests wait for the response
 * and support handling of common HTTP request methods like GET, PUT, POST, DELETE and OPTIONS. When
 * you use Cloud Functions, a TLS certificate is automatically provisioned for you, so all HTTP
 * functions can be invoked via a secure connection.
 *
 * See more information at: https://cloud.google.com/functions/docs/writing/http
 */
export declare class HttpCallbackFunction extends CallbackFunction {
    /**
     * URL which triggers function execution.
     */
    readonly httpsTriggerUrl: pulumi.Output<string>;
    constructor(name: string, callback: HttpCallback, opts?: pulumi.ComponentResourceOptions);
    constructor(name: string, args: HttpCallbackFunctionArgs, opts?: pulumi.ComponentResourceOptions);
}
/**
 * Arguments that control both how a user function is serialized and how the final Cloud Function
 * is created.  Can be used to override values if the defaults are not desirable.
 */
export interface CallbackFunctionArgs {
    /**
     * Options to control which paths/packages should be included or excluded in the zip file containing
     * the code for the GCP Function.
     */
    codePathOptions?: pulumi.runtime.CodePathOptions;
    /**
     * Memory (in MB), available to the function. Default value is 256MB. Allowed values are: 128MB, 256MB, 512MB, 1024MB, and 2048MB.
     */
    availableMemoryMb?: pulumi.Input<number>;
    /**
     * Description of the function.
     */
    description?: pulumi.Input<string>;
    /**
     * A set of key/value environment variable pairs to assign to the function.
     */
    environmentVariables?: pulumi.Input<{
        [key: string]: any;
    }>;
    /**
     * A source that fires events in response to a condition in another service. Structure is
     * documented below. Cannot be used with `trigger_http`.
     */
    eventTrigger?: pulumi.Input<{
        eventType: pulumi.Input<string>;
        failurePolicy?: pulumi.Input<FailurePolicy>;
        resource: pulumi.Input<string>;
    }>;
    /**
     * URL which triggers function execution. Returned only if `trigger_http` is used.
     */
    httpsTriggerUrl?: pulumi.Input<string>;
    /**
     * A set of key/value label pairs to assign to the function.
     */
    labels?: pulumi.Input<{
        [key: string]: any;
    }>;
    /**
     * MaxInstances sets limit on the maximum number of function instances that may coexist at a given time.
     */
    maxInstances?: pulumi.Input<number>;
    /**
     * MinInstances sets limit on minimum number of function instances that may coexist at a given time.
     */
    minInstances?: pulumi.Input<number>;
    /**
     * Location of the function. If it is not provided, the provider location is used.
     */
    location?: pulumi.Input<string>;
    /**
     * Project of the function. If it is not provided, the provider project is used.
     */
    project?: pulumi.Input<string>;
    /**
     * Region of function. Currently can be only "us-central1". If it is not provided, the provider region is used.
     */
    region?: pulumi.Input<string>;
    /**
     * Secret environment variables configuration. Structure is documented below.
     */
    secretEnvironmentVariables?: pulumi.Input<pulumi.Input<inputs.cloudfunctions.FunctionSecretEnvironmentVariable>[]>;
    /**
     * If provided, the self-provided service account to run the function with.
     */
    serviceAccountEmail?: pulumi.Input<string>;
    /**
     * Timeout (in seconds) for the function. Default value is 60 seconds. Cannot be more than 540 seconds.
     */
    timeout?: pulumi.Input<number>;
    /**
     * Boolean variable. Any HTTP request (of a supported type) to the endpoint will trigger function execution. Supported HTTP request types are: POST, PUT,
     * GET, DELETE, and OPTIONS. Endpoint is returned as `https_trigger_url`. Cannot be used with `trigger_bucket` and `trigger_topic`.
     */
    triggerHttp?: pulumi.Input<boolean>;
    /**
     * The Javascript callback to use as the entrypoint for the GCP CloudFunction out of.  Either
     * [callback] or [callbackFactory] must be provided.
     */
    callback?: Function;
    /**
     * The Javascript function instance that will be called to produce the callback function that is
     * the entrypoint for the GCP Cloud Function. Either [callback] or [callbackFactory] must be
     * provided.
     *
     * This form is useful when there is expensive initialization work that should only be executed
     * once.  The factory-function will be invoked once when the final GCP Cloud Function module is
     * loaded. It can run whatever code it needs, and will end by returning the actual function that
     * Function will call into each time the Cloud Function is invoked.
     */
    callbackFactory?: Function;
    /**
     * The bucket to use as the sourceArchiveBucket for the generated CloudFunctions Function source
     * to be placed in.  A fresh [storage.BucketObject] will be made there containing the serialized
     * code.
     */
    bucket?: storage.Bucket;
    /**
     * The specific runtime for the function. If not specified, a default will be applied
     */
    runtime?: pulumi.Input<string>;
    /**
     * The specific member to grant access to the function. If not specifiedm then we default to `allUsers`.
     * Available options are `allAuthenticatedUsers`, `user:{emailid}`, `serviceAccount:{emailid}`,
     * `group:{emailid}` and `domain:{domain}:`
     */
    iamMember?: pulumi.Input<string>;
    /**
     * The specific role to attach to the function. If not specified, then we default to `roles/cloudfunctions.invoker`.
     * Role must be in the format `roles/{role-name}`
     */
    iamRole?: pulumi.Input<string>;
}
/**
 * HttpCallback is the signature for an http triggered GCP CloudFunction entrypoint.
 *
 * [req] is the data passed in by specific services calling the CloudFunction.  See
 * https://expressjs.com/en/api.html#req for more details.
 *
 * [res] is the object that be used to supply the response. See
 * https://expressjs.com/en/api.html#res for more details.
 */
export type HttpCallback = (req: express.Request, res: express.Response) => void;
export type HttpCallbackFactory = () => HttpCallback;
/**
 * Specialized arguments to use when specifically creating an [HttpCallbackFunction].
 */
export interface HttpCallbackFunctionArgs extends CallbackFunctionArgs {
    /**
     * The Javascript callback to use as the entrypoint for the GCP CloudFunction out of.  Either
     * [callback] or [callbackFactory] must be provided.
     */
    callback?: HttpCallback;
    /**
     * The Javascript function instance that will be called to produce the callback function that is
     * the entrypoint for the GCP CloudFunction. Either [callback] or [callbackFactory] must be
     * provided.
     *
     * This form is useful when there is expensive initialization work that should only be executed
     * once.  The factory-function will be invoked once when the final GCP CloudFunction module is
     * loaded. It can run whatever code it needs, and will end by returning the actual function that
     * Function will call into each time the Function is invoked.
     */
    callbackFactory?: HttpCallbackFactory;
    triggerHttp?: never;
    eventTrigger?: never;
}
//# sourceMappingURL=zMixins.d.ts.map