import * as pulumi from "@pulumi/pulumi";
/**
 * This resource provides the Connection resource in Oracle Cloud Infrastructure Data Catalog service.
 * Api doc link for the resource: https://docs.oracle.com/iaas/api/#/en/data-catalog/latest/Connection
 *
 * Example terraform configs related to the resource : https://github.com/oracle/terraform-provider-oci/tree/master/examples/datacatalog
 *
 * Creates a new connection.
 *
 * ## Example Usage
 *
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as oci from "@pulumi/oci";
 *
 * const testConnection = new oci.datacatalog.Connection("test_connection", {
 *     catalogId: testCatalog.id,
 *     dataAssetKey: connectionDataAssetKey,
 *     displayName: connectionDisplayName,
 *     properties: connectionProperties,
 *     typeKey: connectionTypeKey,
 *     description: connectionDescription,
 *     encProperties: connectionEncProperties,
 *     isDefault: connectionIsDefault === "true",
 * });
 * ```
 *
 * ## Import
 *
 * Connections can be imported using the `id`, e.g.
 *
 * ```sh
 * $ pulumi import oci:DataCatalog/connection:Connection test_connection "catalogs/{catalogId}/dataAssets/{dataAssetKey}/connections/{connectionKey}"
 * ```
 */
export declare class Connection extends pulumi.CustomResource {
    /**
     * Get an existing Connection 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 state Any extra arguments used during the lookup.
     * @param opts Optional settings to control the behavior of the CustomResource.
     */
    static get(name: string, id: pulumi.Input<pulumi.ID>, state?: ConnectionState, opts?: pulumi.CustomResourceOptions): Connection;
    /**
     * Returns true if the given object is an instance of Connection.  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 Connection;
    /**
     * Unique catalog identifier.
     */
    readonly catalogId: pulumi.Output<string>;
    /**
     * OCID of the user who created the connection.
     */
    readonly createdById: pulumi.Output<string>;
    /**
     * Unique data asset key.
     */
    readonly dataAssetKey: pulumi.Output<string>;
    /**
     * (Updatable) A description of the connection.
     */
    readonly description: pulumi.Output<string>;
    /**
     * (Updatable) A user-friendly display name. Does not have to be unique, and it's changeable. Avoid entering confidential information.
     */
    readonly displayName: pulumi.Output<string>;
    /**
     * (Updatable) A map of maps that contains the encrypted values for sensitive properties which are specific to the connection type. Each connection type definition defines it's set of required and optional properties. The map keys are category names and the values are maps of property name to property value. Every property is contained inside of a category. Most connections have required properties within the "default" category. To determine the set of optional and required properties for a connection type, a query can be done on '/types?type=connection' that returns a collection of all connection types. The appropriate connection type, which will include definitions of all of it's properties, can be identified from this collection. Example: `{"encProperties": { "default": { "password": "example-password"}}}`
     */
    readonly encProperties: pulumi.Output<{
        [key: string]: string;
    } | undefined>;
    /**
     * Unique external key of this object from the source system.
     */
    readonly externalKey: pulumi.Output<string>;
    /**
     * (Updatable) Indicates whether this connection is the default connection. The first connection of a data asset defaults to being the default, subsequent connections default to not being the default. If a default connection already exists, then trying to create a connection as the default will fail. In this case the default connection would need to be updated not to be the default and then the new connection can then be created as the default.
     */
    readonly isDefault: pulumi.Output<boolean>;
    /**
     * Unique connection key that is immutable.
     */
    readonly key: pulumi.Output<string>;
    /**
     * (Updatable) A map of maps that contains the properties which are specific to the connection type. Each connection type definition defines it's set of required and optional properties. The map keys are category names and the values are maps of property name to property value. Every property is contained inside of a category. Most connections have required properties within the "default" category. To determine the set of optional and required properties for a connection type, a query can be done on '/types?type=connection' that returns a collection of all connection types. The appropriate connection type, which will include definitions of all of it's properties, can be identified from this collection. Example: `{"properties": { "default": { "username": "user1"}}}` . Terraform treats all map of maps as a flattened map with `.` denoting each level. For more information check out this example
     */
    readonly properties: pulumi.Output<{
        [key: string]: string;
    }>;
    /**
     * The current state of the connection.
     */
    readonly state: pulumi.Output<string>;
    /**
     * The date and time the connection was created, in the format defined by [RFC3339](https://tools.ietf.org/html/rfc3339). Example: `2019-03-25T21:10:29.600Z`
     */
    readonly timeCreated: pulumi.Output<string>;
    /**
     * Time that the connections status was last updated. An [RFC3339](https://tools.ietf.org/html/rfc3339) formatted datetime string.
     */
    readonly timeStatusUpdated: pulumi.Output<string>;
    /**
     * The last time that any change was made to the connection. An [RFC3339](https://tools.ietf.org/html/rfc3339) formatted datetime string.
     */
    readonly timeUpdated: pulumi.Output<string>;
    /**
     * The key of the object type. Type key's can be found via the '/types' endpoint.
     *
     *
     * ** IMPORTANT **
     * Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
     */
    readonly typeKey: pulumi.Output<string>;
    /**
     * OCID of the user who modified the connection.
     */
    readonly updatedById: pulumi.Output<string>;
    /**
     * URI to the connection instance in the API.
     */
    readonly uri: pulumi.Output<string>;
    /**
     * Create a Connection 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: ConnectionArgs, opts?: pulumi.CustomResourceOptions);
}
/**
 * Input properties used for looking up and filtering Connection resources.
 */
export interface ConnectionState {
    /**
     * Unique catalog identifier.
     */
    catalogId?: pulumi.Input<string | undefined>;
    /**
     * OCID of the user who created the connection.
     */
    createdById?: pulumi.Input<string | undefined>;
    /**
     * Unique data asset key.
     */
    dataAssetKey?: pulumi.Input<string | undefined>;
    /**
     * (Updatable) A description of the connection.
     */
    description?: pulumi.Input<string | undefined>;
    /**
     * (Updatable) A user-friendly display name. Does not have to be unique, and it's changeable. Avoid entering confidential information.
     */
    displayName?: pulumi.Input<string | undefined>;
    /**
     * (Updatable) A map of maps that contains the encrypted values for sensitive properties which are specific to the connection type. Each connection type definition defines it's set of required and optional properties. The map keys are category names and the values are maps of property name to property value. Every property is contained inside of a category. Most connections have required properties within the "default" category. To determine the set of optional and required properties for a connection type, a query can be done on '/types?type=connection' that returns a collection of all connection types. The appropriate connection type, which will include definitions of all of it's properties, can be identified from this collection. Example: `{"encProperties": { "default": { "password": "example-password"}}}`
     */
    encProperties?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    } | undefined>;
    /**
     * Unique external key of this object from the source system.
     */
    externalKey?: pulumi.Input<string | undefined>;
    /**
     * (Updatable) Indicates whether this connection is the default connection. The first connection of a data asset defaults to being the default, subsequent connections default to not being the default. If a default connection already exists, then trying to create a connection as the default will fail. In this case the default connection would need to be updated not to be the default and then the new connection can then be created as the default.
     */
    isDefault?: pulumi.Input<boolean | undefined>;
    /**
     * Unique connection key that is immutable.
     */
    key?: pulumi.Input<string | undefined>;
    /**
     * (Updatable) A map of maps that contains the properties which are specific to the connection type. Each connection type definition defines it's set of required and optional properties. The map keys are category names and the values are maps of property name to property value. Every property is contained inside of a category. Most connections have required properties within the "default" category. To determine the set of optional and required properties for a connection type, a query can be done on '/types?type=connection' that returns a collection of all connection types. The appropriate connection type, which will include definitions of all of it's properties, can be identified from this collection. Example: `{"properties": { "default": { "username": "user1"}}}` . Terraform treats all map of maps as a flattened map with `.` denoting each level. For more information check out this example
     */
    properties?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    } | undefined>;
    /**
     * The current state of the connection.
     */
    state?: pulumi.Input<string | undefined>;
    /**
     * The date and time the connection was created, in the format defined by [RFC3339](https://tools.ietf.org/html/rfc3339). Example: `2019-03-25T21:10:29.600Z`
     */
    timeCreated?: pulumi.Input<string | undefined>;
    /**
     * Time that the connections status was last updated. An [RFC3339](https://tools.ietf.org/html/rfc3339) formatted datetime string.
     */
    timeStatusUpdated?: pulumi.Input<string | undefined>;
    /**
     * The last time that any change was made to the connection. An [RFC3339](https://tools.ietf.org/html/rfc3339) formatted datetime string.
     */
    timeUpdated?: pulumi.Input<string | undefined>;
    /**
     * The key of the object type. Type key's can be found via the '/types' endpoint.
     *
     *
     * ** IMPORTANT **
     * Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
     */
    typeKey?: pulumi.Input<string | undefined>;
    /**
     * OCID of the user who modified the connection.
     */
    updatedById?: pulumi.Input<string | undefined>;
    /**
     * URI to the connection instance in the API.
     */
    uri?: pulumi.Input<string | undefined>;
}
/**
 * The set of arguments for constructing a Connection resource.
 */
export interface ConnectionArgs {
    /**
     * Unique catalog identifier.
     */
    catalogId: pulumi.Input<string>;
    /**
     * Unique data asset key.
     */
    dataAssetKey: pulumi.Input<string>;
    /**
     * (Updatable) A description of the connection.
     */
    description?: pulumi.Input<string | undefined>;
    /**
     * (Updatable) A user-friendly display name. Does not have to be unique, and it's changeable. Avoid entering confidential information.
     */
    displayName: pulumi.Input<string>;
    /**
     * (Updatable) A map of maps that contains the encrypted values for sensitive properties which are specific to the connection type. Each connection type definition defines it's set of required and optional properties. The map keys are category names and the values are maps of property name to property value. Every property is contained inside of a category. Most connections have required properties within the "default" category. To determine the set of optional and required properties for a connection type, a query can be done on '/types?type=connection' that returns a collection of all connection types. The appropriate connection type, which will include definitions of all of it's properties, can be identified from this collection. Example: `{"encProperties": { "default": { "password": "example-password"}}}`
     */
    encProperties?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    } | undefined>;
    /**
     * (Updatable) Indicates whether this connection is the default connection. The first connection of a data asset defaults to being the default, subsequent connections default to not being the default. If a default connection already exists, then trying to create a connection as the default will fail. In this case the default connection would need to be updated not to be the default and then the new connection can then be created as the default.
     */
    isDefault?: pulumi.Input<boolean | undefined>;
    /**
     * (Updatable) A map of maps that contains the properties which are specific to the connection type. Each connection type definition defines it's set of required and optional properties. The map keys are category names and the values are maps of property name to property value. Every property is contained inside of a category. Most connections have required properties within the "default" category. To determine the set of optional and required properties for a connection type, a query can be done on '/types?type=connection' that returns a collection of all connection types. The appropriate connection type, which will include definitions of all of it's properties, can be identified from this collection. Example: `{"properties": { "default": { "username": "user1"}}}` . Terraform treats all map of maps as a flattened map with `.` denoting each level. For more information check out this example
     */
    properties: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * The key of the object type. Type key's can be found via the '/types' endpoint.
     *
     *
     * ** IMPORTANT **
     * Any change to a property that does not support update will force the destruction and recreation of the resource with the new property values
     */
    typeKey: pulumi.Input<string>;
}
//# sourceMappingURL=connection.d.ts.map