import * as pulumi from "@pulumi/pulumi";
import * as inputs from "../../types/input";
import * as outputs from "../../types/output";
import * as enums from "../../types/enums";
/**
 * Creates a new routine in the dataset.
 * Auto-naming is currently not supported for this resource.
 */
export declare class Routine extends pulumi.CustomResource {
    /**
     * Get an existing Routine resource's state with the given name, ID, and optional extra
     * properties used to qualify the lookup.
     *
     * @param name The _unique_ name of the resulting resource.
     * @param id The _unique_ provider ID of the resource to lookup.
     * @param opts Optional settings to control the behavior of the CustomResource.
     */
    static get(name: string, id: pulumi.Input<pulumi.ID>, opts?: pulumi.CustomResourceOptions): Routine;
    /**
     * Returns true if the given object is an instance of Routine.  This is designed to work even
     * when multiple copies of the Pulumi SDK have been loaded into the same process.
     */
    static isInstance(obj: any): obj is Routine;
    /**
     * Optional.
     */
    readonly arguments: pulumi.Output<outputs.bigquery.v2.ArgumentResponse[]>;
    /**
     * The time when this routine was created, in milliseconds since the epoch.
     */
    readonly creationTime: pulumi.Output<string>;
    /**
     * Optional. If set to `DATA_MASKING`, the function is validated and made available as a masking function. For more information, see [Create custom masking routines](https://cloud.google.com/bigquery/docs/user-defined-functions#custom-mask).
     */
    readonly dataGovernanceType: pulumi.Output<string>;
    readonly datasetId: pulumi.Output<string>;
    /**
     * The body of the routine. For functions, this is the expression in the AS clause. If language=SQL, it is the substring inside (but excluding) the parentheses. For example, for the function created with the following statement: `CREATE FUNCTION JoinLines(x string, y string) as (concat(x, "\n", y))` The definition_body is `concat(x, "\n", y)` (\n is not replaced with linebreak). If language=JAVASCRIPT, it is the evaluated string in the AS clause. For example, for the function created with the following statement: `CREATE FUNCTION f() RETURNS STRING LANGUAGE js AS 'return "\n";\n'` The definition_body is `return "\n";\n` Note that both \n are replaced with linebreaks.
     */
    readonly definitionBody: pulumi.Output<string>;
    /**
     * Optional. The description of the routine, if defined.
     */
    readonly description: pulumi.Output<string>;
    /**
     * Optional. The determinism level of the JavaScript UDF, if defined.
     */
    readonly determinismLevel: pulumi.Output<string>;
    /**
     * A hash of this resource.
     */
    readonly etag: pulumi.Output<string>;
    /**
     * Optional. If language = "JAVASCRIPT", this field stores the path of the imported JAVASCRIPT libraries.
     */
    readonly importedLibraries: pulumi.Output<string[]>;
    /**
     * Optional. Defaults to "SQL" if remote_function_options field is absent, not set otherwise.
     */
    readonly language: pulumi.Output<string>;
    /**
     * The time when this routine was last modified, in milliseconds since the epoch.
     */
    readonly lastModifiedTime: pulumi.Output<string>;
    readonly project: pulumi.Output<string>;
    /**
     * Optional. Remote function specific options.
     */
    readonly remoteFunctionOptions: pulumi.Output<outputs.bigquery.v2.RemoteFunctionOptionsResponse>;
    /**
     * Optional. Can be set only if routine_type = "TABLE_VALUED_FUNCTION". If absent, the return table type is inferred from definition_body at query time in each query that references this routine. If present, then the columns in the evaluated table result will be cast to match the column types specified in return table type, at query time.
     */
    readonly returnTableType: pulumi.Output<outputs.bigquery.v2.StandardSqlTableTypeResponse>;
    /**
     * Optional if language = "SQL"; required otherwise. Cannot be set if routine_type = "TABLE_VALUED_FUNCTION". If absent, the return type is inferred from definition_body at query time in each query that references this routine. If present, then the evaluated result will be cast to the specified returned type at query time. For example, for the functions created with the following statements: * `CREATE FUNCTION Add(x FLOAT64, y FLOAT64) RETURNS FLOAT64 AS (x + y);` * `CREATE FUNCTION Increment(x FLOAT64) AS (Add(x, 1));` * `CREATE FUNCTION Decrement(x FLOAT64) RETURNS FLOAT64 AS (Add(x, -1));` The return_type is `{type_kind: "FLOAT64"}` for `Add` and `Decrement`, and is absent for `Increment` (inferred as FLOAT64 at query time). Suppose the function `Add` is replaced by `CREATE OR REPLACE FUNCTION Add(x INT64, y INT64) AS (x + y);` Then the inferred return type of `Increment` is automatically changed to INT64 at query time, while the return type of `Decrement` remains FLOAT64.
     */
    readonly returnType: pulumi.Output<outputs.bigquery.v2.StandardSqlDataTypeResponse>;
    /**
     * Reference describing the ID of this routine.
     */
    readonly routineReference: pulumi.Output<outputs.bigquery.v2.RoutineReferenceResponse>;
    /**
     * The type of routine.
     */
    readonly routineType: pulumi.Output<string>;
    /**
     * Optional. The security mode of the routine, if defined. If not defined, the security mode is automatically determined from the routine's configuration.
     */
    readonly securityMode: pulumi.Output<string>;
    /**
     * Optional. Spark specific options.
     */
    readonly sparkOptions: pulumi.Output<outputs.bigquery.v2.SparkOptionsResponse>;
    /**
     * Optional. Can be set for procedures only. If true (default), the definition body will be validated in the creation and the updates of the procedure. For procedures with an argument of ANY TYPE, the definition body validtion is not supported at creation/update time, and thus this field must be set to false explicitly.
     */
    readonly strictMode: pulumi.Output<boolean>;
    /**
     * Create a Routine resource with the given unique name, arguments, and options.
     *
     * @param name The _unique_ name of the resource.
     * @param args The arguments to use to populate this resource's properties.
     * @param opts A bag of options that control this resource's behavior.
     */
    constructor(name: string, args: RoutineArgs, opts?: pulumi.CustomResourceOptions);
}
/**
 * The set of arguments for constructing a Routine resource.
 */
export interface RoutineArgs {
    /**
     * Optional.
     */
    arguments?: pulumi.Input<pulumi.Input<inputs.bigquery.v2.ArgumentArgs>[]>;
    /**
     * Optional. If set to `DATA_MASKING`, the function is validated and made available as a masking function. For more information, see [Create custom masking routines](https://cloud.google.com/bigquery/docs/user-defined-functions#custom-mask).
     */
    dataGovernanceType?: pulumi.Input<enums.bigquery.v2.RoutineDataGovernanceType>;
    datasetId: pulumi.Input<string>;
    /**
     * The body of the routine. For functions, this is the expression in the AS clause. If language=SQL, it is the substring inside (but excluding) the parentheses. For example, for the function created with the following statement: `CREATE FUNCTION JoinLines(x string, y string) as (concat(x, "\n", y))` The definition_body is `concat(x, "\n", y)` (\n is not replaced with linebreak). If language=JAVASCRIPT, it is the evaluated string in the AS clause. For example, for the function created with the following statement: `CREATE FUNCTION f() RETURNS STRING LANGUAGE js AS 'return "\n";\n'` The definition_body is `return "\n";\n` Note that both \n are replaced with linebreaks.
     */
    definitionBody: pulumi.Input<string>;
    /**
     * Optional. The description of the routine, if defined.
     */
    description?: pulumi.Input<string>;
    /**
     * Optional. The determinism level of the JavaScript UDF, if defined.
     */
    determinismLevel?: pulumi.Input<enums.bigquery.v2.RoutineDeterminismLevel>;
    /**
     * Optional. If language = "JAVASCRIPT", this field stores the path of the imported JAVASCRIPT libraries.
     */
    importedLibraries?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * Optional. Defaults to "SQL" if remote_function_options field is absent, not set otherwise.
     */
    language?: pulumi.Input<enums.bigquery.v2.RoutineLanguage>;
    project?: pulumi.Input<string>;
    /**
     * Optional. Remote function specific options.
     */
    remoteFunctionOptions?: pulumi.Input<inputs.bigquery.v2.RemoteFunctionOptionsArgs>;
    /**
     * Optional. Can be set only if routine_type = "TABLE_VALUED_FUNCTION". If absent, the return table type is inferred from definition_body at query time in each query that references this routine. If present, then the columns in the evaluated table result will be cast to match the column types specified in return table type, at query time.
     */
    returnTableType?: pulumi.Input<inputs.bigquery.v2.StandardSqlTableTypeArgs>;
    /**
     * Optional if language = "SQL"; required otherwise. Cannot be set if routine_type = "TABLE_VALUED_FUNCTION". If absent, the return type is inferred from definition_body at query time in each query that references this routine. If present, then the evaluated result will be cast to the specified returned type at query time. For example, for the functions created with the following statements: * `CREATE FUNCTION Add(x FLOAT64, y FLOAT64) RETURNS FLOAT64 AS (x + y);` * `CREATE FUNCTION Increment(x FLOAT64) AS (Add(x, 1));` * `CREATE FUNCTION Decrement(x FLOAT64) RETURNS FLOAT64 AS (Add(x, -1));` The return_type is `{type_kind: "FLOAT64"}` for `Add` and `Decrement`, and is absent for `Increment` (inferred as FLOAT64 at query time). Suppose the function `Add` is replaced by `CREATE OR REPLACE FUNCTION Add(x INT64, y INT64) AS (x + y);` Then the inferred return type of `Increment` is automatically changed to INT64 at query time, while the return type of `Decrement` remains FLOAT64.
     */
    returnType?: pulumi.Input<inputs.bigquery.v2.StandardSqlDataTypeArgs>;
    /**
     * Reference describing the ID of this routine.
     */
    routineReference: pulumi.Input<inputs.bigquery.v2.RoutineReferenceArgs>;
    /**
     * The type of routine.
     */
    routineType: pulumi.Input<enums.bigquery.v2.RoutineRoutineType>;
    /**
     * Optional. The security mode of the routine, if defined. If not defined, the security mode is automatically determined from the routine's configuration.
     */
    securityMode?: pulumi.Input<enums.bigquery.v2.RoutineSecurityMode>;
    /**
     * Optional. Spark specific options.
     */
    sparkOptions?: pulumi.Input<inputs.bigquery.v2.SparkOptionsArgs>;
    /**
     * Optional. Can be set for procedures only. If true (default), the definition body will be validated in the creation and the updates of the procedure. For procedures with an argument of ANY TYPE, the definition body validtion is not supported at creation/update time, and thus this field must be set to false explicitly.
     */
    strictMode?: pulumi.Input<boolean>;
}