bigqueryanalyticshub

package
v7.20.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 24, 2024 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type DataExchange 

type DataExchange struct {
	pulumi.CustomResourceState

	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces.
	DataExchangeId pulumi.StringOutput `pulumi:"dataExchangeId"`
	// Description of the data exchange.
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Human-readable display name of the data exchange. The display name must contain only Unicode letters, numbers (0-9), underscores (_), dashes (-), spaces ( ), and must not start or end with spaces.
	//
	// ***
	DisplayName pulumi.StringOutput `pulumi:"displayName"`
	// Documentation describing the data exchange.
	Documentation pulumi.StringPtrOutput `pulumi:"documentation"`
	// Base64 encoded image representing the data exchange.
	Icon pulumi.StringPtrOutput `pulumi:"icon"`
	// Number of listings contained in the data exchange.
	ListingCount pulumi.IntOutput `pulumi:"listingCount"`
	// The name of the location this data exchange.
	Location pulumi.StringOutput `pulumi:"location"`
	// The resource name of the data exchange, for example:
	// "projects/myproject/locations/US/dataExchanges/123"
	Name pulumi.StringOutput `pulumi:"name"`
	// Email or URL of the primary point of contact of the data exchange.
	PrimaryContact pulumi.StringPtrOutput `pulumi:"primaryContact"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
}

A Bigquery Analytics Hub data exchange

To get more information about DataExchange, see:

* [API documentation](https://cloud.google.com/bigquery/docs/reference/analytics-hub/rest/v1/projects.locations.dataExchanges) * How-to Guides

## Example Usage

### Bigquery Analyticshub Data Exchange Basic

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.NewDataExchange(ctx, "data_exchange", &bigqueryanalyticshub.DataExchangeArgs{
			Location:       pulumi.String("US"),
			DataExchangeId: pulumi.String("my_data_exchange"),
			DisplayName:    pulumi.String("my_data_exchange"),
			Description:    pulumi.String("example data exchange"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

DataExchange can be imported using any of these accepted formats:

* `projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}}`

* `{{project}}/{{location}}/{{data_exchange_id}}`

* `{{location}}/{{data_exchange_id}}`

* `{{data_exchange_id}}`

When using the `pulumi import` command, DataExchange can be imported using one of the formats above. For example:

```sh $ pulumi import gcp:bigqueryanalyticshub/dataExchange:DataExchange default projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}} ```

```sh $ pulumi import gcp:bigqueryanalyticshub/dataExchange:DataExchange default {{project}}/{{location}}/{{data_exchange_id}} ```

```sh $ pulumi import gcp:bigqueryanalyticshub/dataExchange:DataExchange default {{location}}/{{data_exchange_id}} ```

```sh $ pulumi import gcp:bigqueryanalyticshub/dataExchange:DataExchange default {{data_exchange_id}} ```

func GetDataExchange 

func GetDataExchange(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *DataExchangeState, opts ...pulumi.ResourceOption) (*DataExchange, error)

GetDataExchange gets an existing DataExchange resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewDataExchange 

func NewDataExchange(ctx *pulumi.Context,
	name string, args *DataExchangeArgs, opts ...pulumi.ResourceOption) (*DataExchange, error)

NewDataExchange registers a new resource with the given unique name, arguments, and options.

func (*DataExchange) ElementType 

func (*DataExchange) ElementType() reflect.Type

func (*DataExchange) ToDataExchangeOutput 

func (i *DataExchange) ToDataExchangeOutput() DataExchangeOutput

func (*DataExchange) ToDataExchangeOutputWithContext 

func (i *DataExchange) ToDataExchangeOutputWithContext(ctx context.Context) DataExchangeOutput

type DataExchangeArgs 

type DataExchangeArgs struct {
	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces.
	DataExchangeId pulumi.StringInput
	// Description of the data exchange.
	Description pulumi.StringPtrInput
	// Human-readable display name of the data exchange. The display name must contain only Unicode letters, numbers (0-9), underscores (_), dashes (-), spaces ( ), and must not start or end with spaces.
	//
	// ***
	DisplayName pulumi.StringInput
	// Documentation describing the data exchange.
	Documentation pulumi.StringPtrInput
	// Base64 encoded image representing the data exchange.
	Icon pulumi.StringPtrInput
	// The name of the location this data exchange.
	Location pulumi.StringInput
	// Email or URL of the primary point of contact of the data exchange.
	PrimaryContact pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
}

The set of arguments for constructing a DataExchange resource.

func (DataExchangeArgs) ElementType 

func (DataExchangeArgs) ElementType() reflect.Type

type DataExchangeArray 

type DataExchangeArray []DataExchangeInput

func (DataExchangeArray) ElementType 

func (DataExchangeArray) ElementType() reflect.Type

func (DataExchangeArray) ToDataExchangeArrayOutput 

func (i DataExchangeArray) ToDataExchangeArrayOutput() DataExchangeArrayOutput

func (DataExchangeArray) ToDataExchangeArrayOutputWithContext 

func (i DataExchangeArray) ToDataExchangeArrayOutputWithContext(ctx context.Context) DataExchangeArrayOutput

type DataExchangeArrayInput 

type DataExchangeArrayInput interface {
	pulumi.Input

	ToDataExchangeArrayOutput() DataExchangeArrayOutput
	ToDataExchangeArrayOutputWithContext(context.Context) DataExchangeArrayOutput
}

DataExchangeArrayInput is an input type that accepts DataExchangeArray and DataExchangeArrayOutput values. You can construct a concrete instance of `DataExchangeArrayInput` via: 

DataExchangeArray{ DataExchangeArgs{...} }

type DataExchangeArrayOutput 

type DataExchangeArrayOutput struct{ *pulumi.OutputState }

func (DataExchangeArrayOutput) ElementType 

func (DataExchangeArrayOutput) ElementType() reflect.Type

func (DataExchangeArrayOutput) Index 

func (o DataExchangeArrayOutput) Index(i pulumi.IntInput) DataExchangeOutput

func (DataExchangeArrayOutput) ToDataExchangeArrayOutput 

func (o DataExchangeArrayOutput) ToDataExchangeArrayOutput() DataExchangeArrayOutput

func (DataExchangeArrayOutput) ToDataExchangeArrayOutputWithContext 

func (o DataExchangeArrayOutput) ToDataExchangeArrayOutputWithContext(ctx context.Context) DataExchangeArrayOutput

type DataExchangeIamBinding 

type DataExchangeIamBinding struct {
	pulumi.CustomResourceState

	Condition DataExchangeIamBindingConditionPtrOutput `pulumi:"condition"`
	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	DataExchangeId pulumi.StringOutput `pulumi:"dataExchangeId"`
	// (Computed) The etag of the IAM policy.
	Etag pulumi.StringOutput `pulumi:"etag"`
	// The name of the location this data exchange.
	// Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringOutput `pulumi:"location"`
	// Identities that will be granted the privilege in `role`.
	// Each entry can have one of the following values:
	// * **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account.
	// * **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account.
	// * **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com.
	// * **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com.
	// * **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com.
	// * **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com.
	// * **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project"
	// * **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project"
	// * **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"
	Members pulumi.StringArrayOutput `pulumi:"members"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
	// The role that should be applied. Only one
	// `bigqueryanalyticshub.DataExchangeIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringOutput `pulumi:"role"`
}

Three different resources help you manage your IAM policy for Bigquery Analytics Hub DataExchange. Each of these resources serves a different use case:

* `bigqueryanalyticshub.DataExchangeIamPolicy`: Authoritative. Sets the IAM policy for the dataexchange and replaces any existing policy already attached. * `bigqueryanalyticshub.DataExchangeIamBinding`: Authoritative for a given role. Updates the IAM policy to grant a role to a list of members. Other roles within the IAM policy for the dataexchange are preserved. * `bigqueryanalyticshub.DataExchangeIamMember`: Non-authoritative. Updates the IAM policy to grant a role to a new member. Other members for the role for the dataexchange are preserved.

A data source can be used to retrieve policy data in advent you do not need creation

* `bigqueryanalyticshub.DataExchangeIamPolicy`: Retrieves the IAM policy for the dataexchange

> **Note:** `bigqueryanalyticshub.DataExchangeIamPolicy` **cannot** be used in conjunction with `bigqueryanalyticshub.DataExchangeIamBinding` and `bigqueryanalyticshub.DataExchangeIamMember` or they will fight over what your policy should be.

> **Note:** `bigqueryanalyticshub.DataExchangeIamBinding` resources **can be** used in conjunction with `bigqueryanalyticshub.DataExchangeIamMember` resources **only if** they do not grant privilege to the same role.

## google\_bigquery\_analytics\_hub\_data\_exchange\_iam\_policy

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				{
					Role: "roles/viewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = bigqueryanalyticshub.NewDataExchangeIamPolicy(ctx, "policy", &bigqueryanalyticshub.DataExchangeIamPolicyArgs{
			Project:        pulumi.Any(dataExchange.Project),
			Location:       pulumi.Any(dataExchange.Location),
			DataExchangeId: pulumi.Any(dataExchange.DataExchangeId),
			PolicyData:     pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_data\_exchange\_iam\_binding

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.NewDataExchangeIamBinding(ctx, "binding", &bigqueryanalyticshub.DataExchangeIamBindingArgs{
			Project:        pulumi.Any(dataExchange.Project),
			Location:       pulumi.Any(dataExchange.Location),
			DataExchangeId: pulumi.Any(dataExchange.DataExchangeId),
			Role:           pulumi.String("roles/viewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_data\_exchange\_iam\_member

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.NewDataExchangeIamMember(ctx, "member", &bigqueryanalyticshub.DataExchangeIamMemberArgs{
			Project:        pulumi.Any(dataExchange.Project),
			Location:       pulumi.Any(dataExchange.Location),
			DataExchangeId: pulumi.Any(dataExchange.DataExchangeId),
			Role:           pulumi.String("roles/viewer"),
			Member:         pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_data\_exchange\_iam\_policy

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				{
					Role: "roles/viewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = bigqueryanalyticshub.NewDataExchangeIamPolicy(ctx, "policy", &bigqueryanalyticshub.DataExchangeIamPolicyArgs{
			Project:        pulumi.Any(dataExchange.Project),
			Location:       pulumi.Any(dataExchange.Location),
			DataExchangeId: pulumi.Any(dataExchange.DataExchangeId),
			PolicyData:     pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_data\_exchange\_iam\_binding

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.NewDataExchangeIamBinding(ctx, "binding", &bigqueryanalyticshub.DataExchangeIamBindingArgs{
			Project:        pulumi.Any(dataExchange.Project),
			Location:       pulumi.Any(dataExchange.Location),
			DataExchangeId: pulumi.Any(dataExchange.DataExchangeId),
			Role:           pulumi.String("roles/viewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_data\_exchange\_iam\_member

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.NewDataExchangeIamMember(ctx, "member", &bigqueryanalyticshub.DataExchangeIamMemberArgs{
			Project:        pulumi.Any(dataExchange.Project),
			Location:       pulumi.Any(dataExchange.Location),
			DataExchangeId: pulumi.Any(dataExchange.DataExchangeId),
			Role:           pulumi.String("roles/viewer"),
			Member:         pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

For all import syntaxes, the "resource in question" can take any of the following forms:

* projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}}

* {{project}}/{{location}}/{{data_exchange_id}}

* {{location}}/{{data_exchange_id}}

* {{data_exchange_id}}

Any variables not passed in the import command will be taken from the provider configuration.

Bigquery Analytics Hub dataexchange IAM resources can be imported using the resource identifiers, role, and member.

IAM member imports use space-delimited identifiers: the resource in question, the role, and the member identity, e.g.

```sh $ pulumi import gcp:bigqueryanalyticshub/dataExchangeIamBinding:DataExchangeIamBinding editor "projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}} roles/viewer user:jane@example.com" ```

IAM binding imports use space-delimited identifiers: the resource in question and the role, e.g.

```sh $ pulumi import gcp:bigqueryanalyticshub/dataExchangeIamBinding:DataExchangeIamBinding editor "projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}} roles/viewer" ```

IAM policy imports use the identifier of the resource in question, e.g.

```sh $ pulumi import gcp:bigqueryanalyticshub/dataExchangeIamBinding:DataExchangeIamBinding editor projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}} ```

-> **Custom Roles**: If you're importing a IAM resource with a custom role, make sure to use the 

full name of the custom role, e.g. `[projects/my-project|organizations/my-org]/roles/my-custom-role`.

func GetDataExchangeIamBinding 

func GetDataExchangeIamBinding(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *DataExchangeIamBindingState, opts ...pulumi.ResourceOption) (*DataExchangeIamBinding, error)

GetDataExchangeIamBinding gets an existing DataExchangeIamBinding resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewDataExchangeIamBinding 

func NewDataExchangeIamBinding(ctx *pulumi.Context,
	name string, args *DataExchangeIamBindingArgs, opts ...pulumi.ResourceOption) (*DataExchangeIamBinding, error)

NewDataExchangeIamBinding registers a new resource with the given unique name, arguments, and options.

func (*DataExchangeIamBinding) ElementType 

func (*DataExchangeIamBinding) ElementType() reflect.Type

func (*DataExchangeIamBinding) ToDataExchangeIamBindingOutput 

func (i *DataExchangeIamBinding) ToDataExchangeIamBindingOutput() DataExchangeIamBindingOutput

func (*DataExchangeIamBinding) ToDataExchangeIamBindingOutputWithContext 

func (i *DataExchangeIamBinding) ToDataExchangeIamBindingOutputWithContext(ctx context.Context) DataExchangeIamBindingOutput

type DataExchangeIamBindingArgs 

type DataExchangeIamBindingArgs struct {
	Condition DataExchangeIamBindingConditionPtrInput
	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	DataExchangeId pulumi.StringInput
	// The name of the location this data exchange.
	// Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringPtrInput
	// Identities that will be granted the privilege in `role`.
	// Each entry can have one of the following values:
	// * **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account.
	// * **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account.
	// * **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com.
	// * **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com.
	// * **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com.
	// * **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com.
	// * **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project"
	// * **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project"
	// * **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"
	Members pulumi.StringArrayInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
	// The role that should be applied. Only one
	// `bigqueryanalyticshub.DataExchangeIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringInput
}

The set of arguments for constructing a DataExchangeIamBinding resource.

func (DataExchangeIamBindingArgs) ElementType 

func (DataExchangeIamBindingArgs) ElementType() reflect.Type

type DataExchangeIamBindingArray 

type DataExchangeIamBindingArray []DataExchangeIamBindingInput

func (DataExchangeIamBindingArray) ElementType 

func (DataExchangeIamBindingArray) ElementType() reflect.Type

func (DataExchangeIamBindingArray) ToDataExchangeIamBindingArrayOutput 

func (i DataExchangeIamBindingArray) ToDataExchangeIamBindingArrayOutput() DataExchangeIamBindingArrayOutput

func (DataExchangeIamBindingArray) ToDataExchangeIamBindingArrayOutputWithContext 

func (i DataExchangeIamBindingArray) ToDataExchangeIamBindingArrayOutputWithContext(ctx context.Context) DataExchangeIamBindingArrayOutput

type DataExchangeIamBindingArrayInput 

type DataExchangeIamBindingArrayInput interface {
	pulumi.Input

	ToDataExchangeIamBindingArrayOutput() DataExchangeIamBindingArrayOutput
	ToDataExchangeIamBindingArrayOutputWithContext(context.Context) DataExchangeIamBindingArrayOutput
}

DataExchangeIamBindingArrayInput is an input type that accepts DataExchangeIamBindingArray and DataExchangeIamBindingArrayOutput values. You can construct a concrete instance of `DataExchangeIamBindingArrayInput` via: 

DataExchangeIamBindingArray{ DataExchangeIamBindingArgs{...} }

type DataExchangeIamBindingArrayOutput 

type DataExchangeIamBindingArrayOutput struct{ *pulumi.OutputState }

func (DataExchangeIamBindingArrayOutput) ElementType 

func (DataExchangeIamBindingArrayOutput) ElementType() reflect.Type

func (DataExchangeIamBindingArrayOutput) Index 

func (o DataExchangeIamBindingArrayOutput) Index(i pulumi.IntInput) DataExchangeIamBindingOutput

func (DataExchangeIamBindingArrayOutput) ToDataExchangeIamBindingArrayOutput 

func (o DataExchangeIamBindingArrayOutput) ToDataExchangeIamBindingArrayOutput() DataExchangeIamBindingArrayOutput

func (DataExchangeIamBindingArrayOutput) ToDataExchangeIamBindingArrayOutputWithContext 

func (o DataExchangeIamBindingArrayOutput) ToDataExchangeIamBindingArrayOutputWithContext(ctx context.Context) DataExchangeIamBindingArrayOutput

type DataExchangeIamBindingCondition 

type DataExchangeIamBindingCondition struct {
	Description *string `pulumi:"description"`
	Expression  string  `pulumi:"expression"`
	Title       string  `pulumi:"title"`
}

type DataExchangeIamBindingConditionArgs 

type DataExchangeIamBindingConditionArgs struct {
	Description pulumi.StringPtrInput `pulumi:"description"`
	Expression  pulumi.StringInput    `pulumi:"expression"`
	Title       pulumi.StringInput    `pulumi:"title"`
}

func (DataExchangeIamBindingConditionArgs) ElementType 

func (DataExchangeIamBindingConditionArgs) ElementType() reflect.Type

func (DataExchangeIamBindingConditionArgs) ToDataExchangeIamBindingConditionOutput 

func (i DataExchangeIamBindingConditionArgs) ToDataExchangeIamBindingConditionOutput() DataExchangeIamBindingConditionOutput

func (DataExchangeIamBindingConditionArgs) ToDataExchangeIamBindingConditionOutputWithContext 

func (i DataExchangeIamBindingConditionArgs) ToDataExchangeIamBindingConditionOutputWithContext(ctx context.Context) DataExchangeIamBindingConditionOutput

func (DataExchangeIamBindingConditionArgs) ToDataExchangeIamBindingConditionPtrOutput 

func (i DataExchangeIamBindingConditionArgs) ToDataExchangeIamBindingConditionPtrOutput() DataExchangeIamBindingConditionPtrOutput

func (DataExchangeIamBindingConditionArgs) ToDataExchangeIamBindingConditionPtrOutputWithContext 

func (i DataExchangeIamBindingConditionArgs) ToDataExchangeIamBindingConditionPtrOutputWithContext(ctx context.Context) DataExchangeIamBindingConditionPtrOutput

type DataExchangeIamBindingConditionInput 

type DataExchangeIamBindingConditionInput interface {
	pulumi.Input

	ToDataExchangeIamBindingConditionOutput() DataExchangeIamBindingConditionOutput
	ToDataExchangeIamBindingConditionOutputWithContext(context.Context) DataExchangeIamBindingConditionOutput
}

DataExchangeIamBindingConditionInput is an input type that accepts DataExchangeIamBindingConditionArgs and DataExchangeIamBindingConditionOutput values. You can construct a concrete instance of `DataExchangeIamBindingConditionInput` via: 

DataExchangeIamBindingConditionArgs{...}

type DataExchangeIamBindingConditionOutput 

type DataExchangeIamBindingConditionOutput struct{ *pulumi.OutputState }

func (DataExchangeIamBindingConditionOutput) Description 

func (o DataExchangeIamBindingConditionOutput) Description() pulumi.StringPtrOutput

func (DataExchangeIamBindingConditionOutput) ElementType 

func (DataExchangeIamBindingConditionOutput) ElementType() reflect.Type

func (DataExchangeIamBindingConditionOutput) Expression 

func (o DataExchangeIamBindingConditionOutput) Expression() pulumi.StringOutput

func (DataExchangeIamBindingConditionOutput) Title 

func (o DataExchangeIamBindingConditionOutput) Title() pulumi.StringOutput

func (DataExchangeIamBindingConditionOutput) ToDataExchangeIamBindingConditionOutput 

func (o DataExchangeIamBindingConditionOutput) ToDataExchangeIamBindingConditionOutput() DataExchangeIamBindingConditionOutput

func (DataExchangeIamBindingConditionOutput) ToDataExchangeIamBindingConditionOutputWithContext 

func (o DataExchangeIamBindingConditionOutput) ToDataExchangeIamBindingConditionOutputWithContext(ctx context.Context) DataExchangeIamBindingConditionOutput

func (DataExchangeIamBindingConditionOutput) ToDataExchangeIamBindingConditionPtrOutput 

func (o DataExchangeIamBindingConditionOutput) ToDataExchangeIamBindingConditionPtrOutput() DataExchangeIamBindingConditionPtrOutput

func (DataExchangeIamBindingConditionOutput) ToDataExchangeIamBindingConditionPtrOutputWithContext 

func (o DataExchangeIamBindingConditionOutput) ToDataExchangeIamBindingConditionPtrOutputWithContext(ctx context.Context) DataExchangeIamBindingConditionPtrOutput

type DataExchangeIamBindingConditionPtrInput 

type DataExchangeIamBindingConditionPtrInput interface {
	pulumi.Input

	ToDataExchangeIamBindingConditionPtrOutput() DataExchangeIamBindingConditionPtrOutput
	ToDataExchangeIamBindingConditionPtrOutputWithContext(context.Context) DataExchangeIamBindingConditionPtrOutput
}

DataExchangeIamBindingConditionPtrInput is an input type that accepts DataExchangeIamBindingConditionArgs, DataExchangeIamBindingConditionPtr and DataExchangeIamBindingConditionPtrOutput values. You can construct a concrete instance of `DataExchangeIamBindingConditionPtrInput` via: 

        DataExchangeIamBindingConditionArgs{...}

or:

        nil

func DataExchangeIamBindingConditionPtr 

func DataExchangeIamBindingConditionPtr(v *DataExchangeIamBindingConditionArgs) DataExchangeIamBindingConditionPtrInput

type DataExchangeIamBindingConditionPtrOutput 

type DataExchangeIamBindingConditionPtrOutput struct{ *pulumi.OutputState }

func (DataExchangeIamBindingConditionPtrOutput) Description 

func (o DataExchangeIamBindingConditionPtrOutput) Description() pulumi.StringPtrOutput

func (DataExchangeIamBindingConditionPtrOutput) Elem 

func (o DataExchangeIamBindingConditionPtrOutput) Elem() DataExchangeIamBindingConditionOutput

func (DataExchangeIamBindingConditionPtrOutput) ElementType 

func (DataExchangeIamBindingConditionPtrOutput) ElementType() reflect.Type

func (DataExchangeIamBindingConditionPtrOutput) Expression 

func (o DataExchangeIamBindingConditionPtrOutput) Expression() pulumi.StringPtrOutput

func (DataExchangeIamBindingConditionPtrOutput) Title 

func (o DataExchangeIamBindingConditionPtrOutput) Title() pulumi.StringPtrOutput

func (DataExchangeIamBindingConditionPtrOutput) ToDataExchangeIamBindingConditionPtrOutput 

func (o DataExchangeIamBindingConditionPtrOutput) ToDataExchangeIamBindingConditionPtrOutput() DataExchangeIamBindingConditionPtrOutput

func (DataExchangeIamBindingConditionPtrOutput) ToDataExchangeIamBindingConditionPtrOutputWithContext 

func (o DataExchangeIamBindingConditionPtrOutput) ToDataExchangeIamBindingConditionPtrOutputWithContext(ctx context.Context) DataExchangeIamBindingConditionPtrOutput

type DataExchangeIamBindingInput 

type DataExchangeIamBindingInput interface {
	pulumi.Input

	ToDataExchangeIamBindingOutput() DataExchangeIamBindingOutput
	ToDataExchangeIamBindingOutputWithContext(ctx context.Context) DataExchangeIamBindingOutput
}

type DataExchangeIamBindingMap 

type DataExchangeIamBindingMap map[string]DataExchangeIamBindingInput

func (DataExchangeIamBindingMap) ElementType 

func (DataExchangeIamBindingMap) ElementType() reflect.Type

func (DataExchangeIamBindingMap) ToDataExchangeIamBindingMapOutput 

func (i DataExchangeIamBindingMap) ToDataExchangeIamBindingMapOutput() DataExchangeIamBindingMapOutput

func (DataExchangeIamBindingMap) ToDataExchangeIamBindingMapOutputWithContext 

func (i DataExchangeIamBindingMap) ToDataExchangeIamBindingMapOutputWithContext(ctx context.Context) DataExchangeIamBindingMapOutput

type DataExchangeIamBindingMapInput 

type DataExchangeIamBindingMapInput interface {
	pulumi.Input

	ToDataExchangeIamBindingMapOutput() DataExchangeIamBindingMapOutput
	ToDataExchangeIamBindingMapOutputWithContext(context.Context) DataExchangeIamBindingMapOutput
}

DataExchangeIamBindingMapInput is an input type that accepts DataExchangeIamBindingMap and DataExchangeIamBindingMapOutput values. You can construct a concrete instance of `DataExchangeIamBindingMapInput` via: 

DataExchangeIamBindingMap{ "key": DataExchangeIamBindingArgs{...} }

type DataExchangeIamBindingMapOutput 

type DataExchangeIamBindingMapOutput struct{ *pulumi.OutputState }

func (DataExchangeIamBindingMapOutput) ElementType 

func (DataExchangeIamBindingMapOutput) ElementType() reflect.Type

func (DataExchangeIamBindingMapOutput) MapIndex 

func (o DataExchangeIamBindingMapOutput) MapIndex(k pulumi.StringInput) DataExchangeIamBindingOutput

func (DataExchangeIamBindingMapOutput) ToDataExchangeIamBindingMapOutput 

func (o DataExchangeIamBindingMapOutput) ToDataExchangeIamBindingMapOutput() DataExchangeIamBindingMapOutput

func (DataExchangeIamBindingMapOutput) ToDataExchangeIamBindingMapOutputWithContext 

func (o DataExchangeIamBindingMapOutput) ToDataExchangeIamBindingMapOutputWithContext(ctx context.Context) DataExchangeIamBindingMapOutput

type DataExchangeIamBindingOutput 

type DataExchangeIamBindingOutput struct{ *pulumi.OutputState }

func (DataExchangeIamBindingOutput) Condition 

func (o DataExchangeIamBindingOutput) Condition() DataExchangeIamBindingConditionPtrOutput

func (DataExchangeIamBindingOutput) DataExchangeId 

func (o DataExchangeIamBindingOutput) DataExchangeId() pulumi.StringOutput

The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to

func (DataExchangeIamBindingOutput) ElementType 

func (DataExchangeIamBindingOutput) ElementType() reflect.Type

func (DataExchangeIamBindingOutput) Etag 

func (o DataExchangeIamBindingOutput) Etag() pulumi.StringOutput

(Computed) The etag of the IAM policy.

func (DataExchangeIamBindingOutput) Location 

func (o DataExchangeIamBindingOutput) Location() pulumi.StringOutput

The name of the location this data exchange. Used to find the parent resource to bind the IAM policy to

func (DataExchangeIamBindingOutput) Members 

func (o DataExchangeIamBindingOutput) Members() pulumi.StringArrayOutput

Identities that will be granted the privilege in `role`. Each entry can have one of the following values: * **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account. * **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account. * **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com. * **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com. * **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com. * **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com. * **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project" * **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project" * **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"

func (DataExchangeIamBindingOutput) Project 

func (o DataExchangeIamBindingOutput) Project() pulumi.StringOutput

The ID of the project in which the resource belongs. If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.

func (DataExchangeIamBindingOutput) Role 

func (o DataExchangeIamBindingOutput) Role() pulumi.StringOutput

The role that should be applied. Only one `bigqueryanalyticshub.DataExchangeIamBinding` can be used per role. Note that custom roles must be of the format `[projects|organizations]/{parent-name}/roles/{role-name}`.

func (DataExchangeIamBindingOutput) ToDataExchangeIamBindingOutput 

func (o DataExchangeIamBindingOutput) ToDataExchangeIamBindingOutput() DataExchangeIamBindingOutput

func (DataExchangeIamBindingOutput) ToDataExchangeIamBindingOutputWithContext 

func (o DataExchangeIamBindingOutput) ToDataExchangeIamBindingOutputWithContext(ctx context.Context) DataExchangeIamBindingOutput

type DataExchangeIamBindingState 

type DataExchangeIamBindingState struct {
	Condition DataExchangeIamBindingConditionPtrInput
	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	DataExchangeId pulumi.StringPtrInput
	// (Computed) The etag of the IAM policy.
	Etag pulumi.StringPtrInput
	// The name of the location this data exchange.
	// Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringPtrInput
	// Identities that will be granted the privilege in `role`.
	// Each entry can have one of the following values:
	// * **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account.
	// * **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account.
	// * **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com.
	// * **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com.
	// * **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com.
	// * **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com.
	// * **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project"
	// * **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project"
	// * **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"
	Members pulumi.StringArrayInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
	// The role that should be applied. Only one
	// `bigqueryanalyticshub.DataExchangeIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringPtrInput
}

func (DataExchangeIamBindingState) ElementType 

func (DataExchangeIamBindingState) ElementType() reflect.Type

type DataExchangeIamMember 

type DataExchangeIamMember struct {
	pulumi.CustomResourceState

	Condition DataExchangeIamMemberConditionPtrOutput `pulumi:"condition"`
	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	DataExchangeId pulumi.StringOutput `pulumi:"dataExchangeId"`
	// (Computed) The etag of the IAM policy.
	Etag pulumi.StringOutput `pulumi:"etag"`
	// The name of the location this data exchange.
	// Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringOutput `pulumi:"location"`
	// Identities that will be granted the privilege in `role`.
	// Each entry can have one of the following values:
	// * **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account.
	// * **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account.
	// * **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com.
	// * **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com.
	// * **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com.
	// * **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com.
	// * **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project"
	// * **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project"
	// * **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"
	Member pulumi.StringOutput `pulumi:"member"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
	// The role that should be applied. Only one
	// `bigqueryanalyticshub.DataExchangeIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringOutput `pulumi:"role"`
}

Three different resources help you manage your IAM policy for Bigquery Analytics Hub DataExchange. Each of these resources serves a different use case:

* `bigqueryanalyticshub.DataExchangeIamPolicy`: Authoritative. Sets the IAM policy for the dataexchange and replaces any existing policy already attached. * `bigqueryanalyticshub.DataExchangeIamBinding`: Authoritative for a given role. Updates the IAM policy to grant a role to a list of members. Other roles within the IAM policy for the dataexchange are preserved. * `bigqueryanalyticshub.DataExchangeIamMember`: Non-authoritative. Updates the IAM policy to grant a role to a new member. Other members for the role for the dataexchange are preserved.

A data source can be used to retrieve policy data in advent you do not need creation

* `bigqueryanalyticshub.DataExchangeIamPolicy`: Retrieves the IAM policy for the dataexchange

> **Note:** `bigqueryanalyticshub.DataExchangeIamPolicy` **cannot** be used in conjunction with `bigqueryanalyticshub.DataExchangeIamBinding` and `bigqueryanalyticshub.DataExchangeIamMember` or they will fight over what your policy should be.

> **Note:** `bigqueryanalyticshub.DataExchangeIamBinding` resources **can be** used in conjunction with `bigqueryanalyticshub.DataExchangeIamMember` resources **only if** they do not grant privilege to the same role.

## google\_bigquery\_analytics\_hub\_data\_exchange\_iam\_policy

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				{
					Role: "roles/viewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = bigqueryanalyticshub.NewDataExchangeIamPolicy(ctx, "policy", &bigqueryanalyticshub.DataExchangeIamPolicyArgs{
			Project:        pulumi.Any(dataExchange.Project),
			Location:       pulumi.Any(dataExchange.Location),
			DataExchangeId: pulumi.Any(dataExchange.DataExchangeId),
			PolicyData:     pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_data\_exchange\_iam\_binding

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.NewDataExchangeIamBinding(ctx, "binding", &bigqueryanalyticshub.DataExchangeIamBindingArgs{
			Project:        pulumi.Any(dataExchange.Project),
			Location:       pulumi.Any(dataExchange.Location),
			DataExchangeId: pulumi.Any(dataExchange.DataExchangeId),
			Role:           pulumi.String("roles/viewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_data\_exchange\_iam\_member

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.NewDataExchangeIamMember(ctx, "member", &bigqueryanalyticshub.DataExchangeIamMemberArgs{
			Project:        pulumi.Any(dataExchange.Project),
			Location:       pulumi.Any(dataExchange.Location),
			DataExchangeId: pulumi.Any(dataExchange.DataExchangeId),
			Role:           pulumi.String("roles/viewer"),
			Member:         pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_data\_exchange\_iam\_policy

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				{
					Role: "roles/viewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = bigqueryanalyticshub.NewDataExchangeIamPolicy(ctx, "policy", &bigqueryanalyticshub.DataExchangeIamPolicyArgs{
			Project:        pulumi.Any(dataExchange.Project),
			Location:       pulumi.Any(dataExchange.Location),
			DataExchangeId: pulumi.Any(dataExchange.DataExchangeId),
			PolicyData:     pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_data\_exchange\_iam\_binding

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.NewDataExchangeIamBinding(ctx, "binding", &bigqueryanalyticshub.DataExchangeIamBindingArgs{
			Project:        pulumi.Any(dataExchange.Project),
			Location:       pulumi.Any(dataExchange.Location),
			DataExchangeId: pulumi.Any(dataExchange.DataExchangeId),
			Role:           pulumi.String("roles/viewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_data\_exchange\_iam\_member

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.NewDataExchangeIamMember(ctx, "member", &bigqueryanalyticshub.DataExchangeIamMemberArgs{
			Project:        pulumi.Any(dataExchange.Project),
			Location:       pulumi.Any(dataExchange.Location),
			DataExchangeId: pulumi.Any(dataExchange.DataExchangeId),
			Role:           pulumi.String("roles/viewer"),
			Member:         pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

For all import syntaxes, the "resource in question" can take any of the following forms:

* projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}}

* {{project}}/{{location}}/{{data_exchange_id}}

* {{location}}/{{data_exchange_id}}

* {{data_exchange_id}}

Any variables not passed in the import command will be taken from the provider configuration.

Bigquery Analytics Hub dataexchange IAM resources can be imported using the resource identifiers, role, and member.

IAM member imports use space-delimited identifiers: the resource in question, the role, and the member identity, e.g.

```sh $ pulumi import gcp:bigqueryanalyticshub/dataExchangeIamMember:DataExchangeIamMember editor "projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}} roles/viewer user:jane@example.com" ```

IAM binding imports use space-delimited identifiers: the resource in question and the role, e.g.

```sh $ pulumi import gcp:bigqueryanalyticshub/dataExchangeIamMember:DataExchangeIamMember editor "projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}} roles/viewer" ```

IAM policy imports use the identifier of the resource in question, e.g.

```sh $ pulumi import gcp:bigqueryanalyticshub/dataExchangeIamMember:DataExchangeIamMember editor projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}} ```

-> **Custom Roles**: If you're importing a IAM resource with a custom role, make sure to use the 

full name of the custom role, e.g. `[projects/my-project|organizations/my-org]/roles/my-custom-role`.

func GetDataExchangeIamMember 

func GetDataExchangeIamMember(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *DataExchangeIamMemberState, opts ...pulumi.ResourceOption) (*DataExchangeIamMember, error)

GetDataExchangeIamMember gets an existing DataExchangeIamMember resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewDataExchangeIamMember 

func NewDataExchangeIamMember(ctx *pulumi.Context,
	name string, args *DataExchangeIamMemberArgs, opts ...pulumi.ResourceOption) (*DataExchangeIamMember, error)

NewDataExchangeIamMember registers a new resource with the given unique name, arguments, and options.

func (*DataExchangeIamMember) ElementType 

func (*DataExchangeIamMember) ElementType() reflect.Type

func (*DataExchangeIamMember) ToDataExchangeIamMemberOutput 

func (i *DataExchangeIamMember) ToDataExchangeIamMemberOutput() DataExchangeIamMemberOutput

func (*DataExchangeIamMember) ToDataExchangeIamMemberOutputWithContext 

func (i *DataExchangeIamMember) ToDataExchangeIamMemberOutputWithContext(ctx context.Context) DataExchangeIamMemberOutput

type DataExchangeIamMemberArgs 

type DataExchangeIamMemberArgs struct {
	Condition DataExchangeIamMemberConditionPtrInput
	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	DataExchangeId pulumi.StringInput
	// The name of the location this data exchange.
	// Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringPtrInput
	// Identities that will be granted the privilege in `role`.
	// Each entry can have one of the following values:
	// * **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account.
	// * **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account.
	// * **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com.
	// * **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com.
	// * **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com.
	// * **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com.
	// * **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project"
	// * **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project"
	// * **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"
	Member pulumi.StringInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
	// The role that should be applied. Only one
	// `bigqueryanalyticshub.DataExchangeIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringInput
}

The set of arguments for constructing a DataExchangeIamMember resource.

func (DataExchangeIamMemberArgs) ElementType 

func (DataExchangeIamMemberArgs) ElementType() reflect.Type

type DataExchangeIamMemberArray 

type DataExchangeIamMemberArray []DataExchangeIamMemberInput

func (DataExchangeIamMemberArray) ElementType 

func (DataExchangeIamMemberArray) ElementType() reflect.Type

func (DataExchangeIamMemberArray) ToDataExchangeIamMemberArrayOutput 

func (i DataExchangeIamMemberArray) ToDataExchangeIamMemberArrayOutput() DataExchangeIamMemberArrayOutput

func (DataExchangeIamMemberArray) ToDataExchangeIamMemberArrayOutputWithContext 

func (i DataExchangeIamMemberArray) ToDataExchangeIamMemberArrayOutputWithContext(ctx context.Context) DataExchangeIamMemberArrayOutput

type DataExchangeIamMemberArrayInput 

type DataExchangeIamMemberArrayInput interface {
	pulumi.Input

	ToDataExchangeIamMemberArrayOutput() DataExchangeIamMemberArrayOutput
	ToDataExchangeIamMemberArrayOutputWithContext(context.Context) DataExchangeIamMemberArrayOutput
}

DataExchangeIamMemberArrayInput is an input type that accepts DataExchangeIamMemberArray and DataExchangeIamMemberArrayOutput values. You can construct a concrete instance of `DataExchangeIamMemberArrayInput` via: 

DataExchangeIamMemberArray{ DataExchangeIamMemberArgs{...} }

type DataExchangeIamMemberArrayOutput 

type DataExchangeIamMemberArrayOutput struct{ *pulumi.OutputState }

func (DataExchangeIamMemberArrayOutput) ElementType 

func (DataExchangeIamMemberArrayOutput) ElementType() reflect.Type

func (DataExchangeIamMemberArrayOutput) Index 

func (o DataExchangeIamMemberArrayOutput) Index(i pulumi.IntInput) DataExchangeIamMemberOutput

func (DataExchangeIamMemberArrayOutput) ToDataExchangeIamMemberArrayOutput 

func (o DataExchangeIamMemberArrayOutput) ToDataExchangeIamMemberArrayOutput() DataExchangeIamMemberArrayOutput

func (DataExchangeIamMemberArrayOutput) ToDataExchangeIamMemberArrayOutputWithContext 

func (o DataExchangeIamMemberArrayOutput) ToDataExchangeIamMemberArrayOutputWithContext(ctx context.Context) DataExchangeIamMemberArrayOutput

type DataExchangeIamMemberCondition 

type DataExchangeIamMemberCondition struct {
	Description *string `pulumi:"description"`
	Expression  string  `pulumi:"expression"`
	Title       string  `pulumi:"title"`
}

type DataExchangeIamMemberConditionArgs 

type DataExchangeIamMemberConditionArgs struct {
	Description pulumi.StringPtrInput `pulumi:"description"`
	Expression  pulumi.StringInput    `pulumi:"expression"`
	Title       pulumi.StringInput    `pulumi:"title"`
}

func (DataExchangeIamMemberConditionArgs) ElementType 

func (DataExchangeIamMemberConditionArgs) ElementType() reflect.Type

func (DataExchangeIamMemberConditionArgs) ToDataExchangeIamMemberConditionOutput 

func (i DataExchangeIamMemberConditionArgs) ToDataExchangeIamMemberConditionOutput() DataExchangeIamMemberConditionOutput

func (DataExchangeIamMemberConditionArgs) ToDataExchangeIamMemberConditionOutputWithContext 

func (i DataExchangeIamMemberConditionArgs) ToDataExchangeIamMemberConditionOutputWithContext(ctx context.Context) DataExchangeIamMemberConditionOutput

func (DataExchangeIamMemberConditionArgs) ToDataExchangeIamMemberConditionPtrOutput 

func (i DataExchangeIamMemberConditionArgs) ToDataExchangeIamMemberConditionPtrOutput() DataExchangeIamMemberConditionPtrOutput

func (DataExchangeIamMemberConditionArgs) ToDataExchangeIamMemberConditionPtrOutputWithContext 

func (i DataExchangeIamMemberConditionArgs) ToDataExchangeIamMemberConditionPtrOutputWithContext(ctx context.Context) DataExchangeIamMemberConditionPtrOutput

type DataExchangeIamMemberConditionInput 

type DataExchangeIamMemberConditionInput interface {
	pulumi.Input

	ToDataExchangeIamMemberConditionOutput() DataExchangeIamMemberConditionOutput
	ToDataExchangeIamMemberConditionOutputWithContext(context.Context) DataExchangeIamMemberConditionOutput
}

DataExchangeIamMemberConditionInput is an input type that accepts DataExchangeIamMemberConditionArgs and DataExchangeIamMemberConditionOutput values. You can construct a concrete instance of `DataExchangeIamMemberConditionInput` via: 

DataExchangeIamMemberConditionArgs{...}

type DataExchangeIamMemberConditionOutput 

type DataExchangeIamMemberConditionOutput struct{ *pulumi.OutputState }

func (DataExchangeIamMemberConditionOutput) Description 

func (o DataExchangeIamMemberConditionOutput) Description() pulumi.StringPtrOutput

func (DataExchangeIamMemberConditionOutput) ElementType 

func (DataExchangeIamMemberConditionOutput) ElementType() reflect.Type

func (DataExchangeIamMemberConditionOutput) Expression 

func (o DataExchangeIamMemberConditionOutput) Expression() pulumi.StringOutput

func (DataExchangeIamMemberConditionOutput) Title 

func (o DataExchangeIamMemberConditionOutput) Title() pulumi.StringOutput

func (DataExchangeIamMemberConditionOutput) ToDataExchangeIamMemberConditionOutput 

func (o DataExchangeIamMemberConditionOutput) ToDataExchangeIamMemberConditionOutput() DataExchangeIamMemberConditionOutput

func (DataExchangeIamMemberConditionOutput) ToDataExchangeIamMemberConditionOutputWithContext 

func (o DataExchangeIamMemberConditionOutput) ToDataExchangeIamMemberConditionOutputWithContext(ctx context.Context) DataExchangeIamMemberConditionOutput

func (DataExchangeIamMemberConditionOutput) ToDataExchangeIamMemberConditionPtrOutput 

func (o DataExchangeIamMemberConditionOutput) ToDataExchangeIamMemberConditionPtrOutput() DataExchangeIamMemberConditionPtrOutput

func (DataExchangeIamMemberConditionOutput) ToDataExchangeIamMemberConditionPtrOutputWithContext 

func (o DataExchangeIamMemberConditionOutput) ToDataExchangeIamMemberConditionPtrOutputWithContext(ctx context.Context) DataExchangeIamMemberConditionPtrOutput

type DataExchangeIamMemberConditionPtrInput 

type DataExchangeIamMemberConditionPtrInput interface {
	pulumi.Input

	ToDataExchangeIamMemberConditionPtrOutput() DataExchangeIamMemberConditionPtrOutput
	ToDataExchangeIamMemberConditionPtrOutputWithContext(context.Context) DataExchangeIamMemberConditionPtrOutput
}

DataExchangeIamMemberConditionPtrInput is an input type that accepts DataExchangeIamMemberConditionArgs, DataExchangeIamMemberConditionPtr and DataExchangeIamMemberConditionPtrOutput values. You can construct a concrete instance of `DataExchangeIamMemberConditionPtrInput` via: 

        DataExchangeIamMemberConditionArgs{...}

or:

        nil

func DataExchangeIamMemberConditionPtr 

func DataExchangeIamMemberConditionPtr(v *DataExchangeIamMemberConditionArgs) DataExchangeIamMemberConditionPtrInput

type DataExchangeIamMemberConditionPtrOutput 

type DataExchangeIamMemberConditionPtrOutput struct{ *pulumi.OutputState }

func (DataExchangeIamMemberConditionPtrOutput) Description 

func (o DataExchangeIamMemberConditionPtrOutput) Description() pulumi.StringPtrOutput

func (DataExchangeIamMemberConditionPtrOutput) Elem 

func (o DataExchangeIamMemberConditionPtrOutput) Elem() DataExchangeIamMemberConditionOutput

func (DataExchangeIamMemberConditionPtrOutput) ElementType 

func (DataExchangeIamMemberConditionPtrOutput) ElementType() reflect.Type

func (DataExchangeIamMemberConditionPtrOutput) Expression 

func (o DataExchangeIamMemberConditionPtrOutput) Expression() pulumi.StringPtrOutput

func (DataExchangeIamMemberConditionPtrOutput) Title 

func (o DataExchangeIamMemberConditionPtrOutput) Title() pulumi.StringPtrOutput

func (DataExchangeIamMemberConditionPtrOutput) ToDataExchangeIamMemberConditionPtrOutput 

func (o DataExchangeIamMemberConditionPtrOutput) ToDataExchangeIamMemberConditionPtrOutput() DataExchangeIamMemberConditionPtrOutput

func (DataExchangeIamMemberConditionPtrOutput) ToDataExchangeIamMemberConditionPtrOutputWithContext 

func (o DataExchangeIamMemberConditionPtrOutput) ToDataExchangeIamMemberConditionPtrOutputWithContext(ctx context.Context) DataExchangeIamMemberConditionPtrOutput

type DataExchangeIamMemberInput 

type DataExchangeIamMemberInput interface {
	pulumi.Input

	ToDataExchangeIamMemberOutput() DataExchangeIamMemberOutput
	ToDataExchangeIamMemberOutputWithContext(ctx context.Context) DataExchangeIamMemberOutput
}

type DataExchangeIamMemberMap 

type DataExchangeIamMemberMap map[string]DataExchangeIamMemberInput

func (DataExchangeIamMemberMap) ElementType 

func (DataExchangeIamMemberMap) ElementType() reflect.Type

func (DataExchangeIamMemberMap) ToDataExchangeIamMemberMapOutput 

func (i DataExchangeIamMemberMap) ToDataExchangeIamMemberMapOutput() DataExchangeIamMemberMapOutput

func (DataExchangeIamMemberMap) ToDataExchangeIamMemberMapOutputWithContext 

func (i DataExchangeIamMemberMap) ToDataExchangeIamMemberMapOutputWithContext(ctx context.Context) DataExchangeIamMemberMapOutput

type DataExchangeIamMemberMapInput 

type DataExchangeIamMemberMapInput interface {
	pulumi.Input

	ToDataExchangeIamMemberMapOutput() DataExchangeIamMemberMapOutput
	ToDataExchangeIamMemberMapOutputWithContext(context.Context) DataExchangeIamMemberMapOutput
}

DataExchangeIamMemberMapInput is an input type that accepts DataExchangeIamMemberMap and DataExchangeIamMemberMapOutput values. You can construct a concrete instance of `DataExchangeIamMemberMapInput` via: 

DataExchangeIamMemberMap{ "key": DataExchangeIamMemberArgs{...} }

type DataExchangeIamMemberMapOutput 

type DataExchangeIamMemberMapOutput struct{ *pulumi.OutputState }

func (DataExchangeIamMemberMapOutput) ElementType 

func (DataExchangeIamMemberMapOutput) ElementType() reflect.Type

func (DataExchangeIamMemberMapOutput) MapIndex 

func (o DataExchangeIamMemberMapOutput) MapIndex(k pulumi.StringInput) DataExchangeIamMemberOutput

func (DataExchangeIamMemberMapOutput) ToDataExchangeIamMemberMapOutput 

func (o DataExchangeIamMemberMapOutput) ToDataExchangeIamMemberMapOutput() DataExchangeIamMemberMapOutput

func (DataExchangeIamMemberMapOutput) ToDataExchangeIamMemberMapOutputWithContext 

func (o DataExchangeIamMemberMapOutput) ToDataExchangeIamMemberMapOutputWithContext(ctx context.Context) DataExchangeIamMemberMapOutput

type DataExchangeIamMemberOutput 

type DataExchangeIamMemberOutput struct{ *pulumi.OutputState }

func (DataExchangeIamMemberOutput) Condition 

func (o DataExchangeIamMemberOutput) Condition() DataExchangeIamMemberConditionPtrOutput

func (DataExchangeIamMemberOutput) DataExchangeId 

func (o DataExchangeIamMemberOutput) DataExchangeId() pulumi.StringOutput

The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to

func (DataExchangeIamMemberOutput) ElementType 

func (DataExchangeIamMemberOutput) ElementType() reflect.Type

func (DataExchangeIamMemberOutput) Etag 

func (o DataExchangeIamMemberOutput) Etag() pulumi.StringOutput

(Computed) The etag of the IAM policy.

func (DataExchangeIamMemberOutput) Location 

func (o DataExchangeIamMemberOutput) Location() pulumi.StringOutput

The name of the location this data exchange. Used to find the parent resource to bind the IAM policy to

func (DataExchangeIamMemberOutput) Member 

func (o DataExchangeIamMemberOutput) Member() pulumi.StringOutput

Identities that will be granted the privilege in `role`. Each entry can have one of the following values: * **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account. * **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account. * **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com. * **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com. * **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com. * **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com. * **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project" * **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project" * **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"

func (DataExchangeIamMemberOutput) Project 

func (o DataExchangeIamMemberOutput) Project() pulumi.StringOutput

The ID of the project in which the resource belongs. If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.

func (DataExchangeIamMemberOutput) Role 

func (o DataExchangeIamMemberOutput) Role() pulumi.StringOutput

The role that should be applied. Only one `bigqueryanalyticshub.DataExchangeIamBinding` can be used per role. Note that custom roles must be of the format `[projects|organizations]/{parent-name}/roles/{role-name}`.

func (DataExchangeIamMemberOutput) ToDataExchangeIamMemberOutput 

func (o DataExchangeIamMemberOutput) ToDataExchangeIamMemberOutput() DataExchangeIamMemberOutput

func (DataExchangeIamMemberOutput) ToDataExchangeIamMemberOutputWithContext 

func (o DataExchangeIamMemberOutput) ToDataExchangeIamMemberOutputWithContext(ctx context.Context) DataExchangeIamMemberOutput

type DataExchangeIamMemberState 

type DataExchangeIamMemberState struct {
	Condition DataExchangeIamMemberConditionPtrInput
	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	DataExchangeId pulumi.StringPtrInput
	// (Computed) The etag of the IAM policy.
	Etag pulumi.StringPtrInput
	// The name of the location this data exchange.
	// Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringPtrInput
	// Identities that will be granted the privilege in `role`.
	// Each entry can have one of the following values:
	// * **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account.
	// * **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account.
	// * **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com.
	// * **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com.
	// * **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com.
	// * **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com.
	// * **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project"
	// * **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project"
	// * **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"
	Member pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
	// The role that should be applied. Only one
	// `bigqueryanalyticshub.DataExchangeIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringPtrInput
}

func (DataExchangeIamMemberState) ElementType 

func (DataExchangeIamMemberState) ElementType() reflect.Type

type DataExchangeIamPolicy 

type DataExchangeIamPolicy struct {
	pulumi.CustomResourceState

	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	DataExchangeId pulumi.StringOutput `pulumi:"dataExchangeId"`
	// (Computed) The etag of the IAM policy.
	Etag pulumi.StringOutput `pulumi:"etag"`
	// The name of the location this data exchange.
	// Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringOutput `pulumi:"location"`
	// The policy data generated by
	// a `organizations.getIAMPolicy` data source.
	PolicyData pulumi.StringOutput `pulumi:"policyData"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
}

Three different resources help you manage your IAM policy for Bigquery Analytics Hub DataExchange. Each of these resources serves a different use case:

* `bigqueryanalyticshub.DataExchangeIamPolicy`: Authoritative. Sets the IAM policy for the dataexchange and replaces any existing policy already attached. * `bigqueryanalyticshub.DataExchangeIamBinding`: Authoritative for a given role. Updates the IAM policy to grant a role to a list of members. Other roles within the IAM policy for the dataexchange are preserved. * `bigqueryanalyticshub.DataExchangeIamMember`: Non-authoritative. Updates the IAM policy to grant a role to a new member. Other members for the role for the dataexchange are preserved.

A data source can be used to retrieve policy data in advent you do not need creation

* `bigqueryanalyticshub.DataExchangeIamPolicy`: Retrieves the IAM policy for the dataexchange

> **Note:** `bigqueryanalyticshub.DataExchangeIamPolicy` **cannot** be used in conjunction with `bigqueryanalyticshub.DataExchangeIamBinding` and `bigqueryanalyticshub.DataExchangeIamMember` or they will fight over what your policy should be.

> **Note:** `bigqueryanalyticshub.DataExchangeIamBinding` resources **can be** used in conjunction with `bigqueryanalyticshub.DataExchangeIamMember` resources **only if** they do not grant privilege to the same role.

## google\_bigquery\_analytics\_hub\_data\_exchange\_iam\_policy

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				{
					Role: "roles/viewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = bigqueryanalyticshub.NewDataExchangeIamPolicy(ctx, "policy", &bigqueryanalyticshub.DataExchangeIamPolicyArgs{
			Project:        pulumi.Any(dataExchange.Project),
			Location:       pulumi.Any(dataExchange.Location),
			DataExchangeId: pulumi.Any(dataExchange.DataExchangeId),
			PolicyData:     pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_data\_exchange\_iam\_binding

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.NewDataExchangeIamBinding(ctx, "binding", &bigqueryanalyticshub.DataExchangeIamBindingArgs{
			Project:        pulumi.Any(dataExchange.Project),
			Location:       pulumi.Any(dataExchange.Location),
			DataExchangeId: pulumi.Any(dataExchange.DataExchangeId),
			Role:           pulumi.String("roles/viewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_data\_exchange\_iam\_member

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.NewDataExchangeIamMember(ctx, "member", &bigqueryanalyticshub.DataExchangeIamMemberArgs{
			Project:        pulumi.Any(dataExchange.Project),
			Location:       pulumi.Any(dataExchange.Location),
			DataExchangeId: pulumi.Any(dataExchange.DataExchangeId),
			Role:           pulumi.String("roles/viewer"),
			Member:         pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_data\_exchange\_iam\_policy

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				{
					Role: "roles/viewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = bigqueryanalyticshub.NewDataExchangeIamPolicy(ctx, "policy", &bigqueryanalyticshub.DataExchangeIamPolicyArgs{
			Project:        pulumi.Any(dataExchange.Project),
			Location:       pulumi.Any(dataExchange.Location),
			DataExchangeId: pulumi.Any(dataExchange.DataExchangeId),
			PolicyData:     pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_data\_exchange\_iam\_binding

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.NewDataExchangeIamBinding(ctx, "binding", &bigqueryanalyticshub.DataExchangeIamBindingArgs{
			Project:        pulumi.Any(dataExchange.Project),
			Location:       pulumi.Any(dataExchange.Location),
			DataExchangeId: pulumi.Any(dataExchange.DataExchangeId),
			Role:           pulumi.String("roles/viewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_data\_exchange\_iam\_member

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.NewDataExchangeIamMember(ctx, "member", &bigqueryanalyticshub.DataExchangeIamMemberArgs{
			Project:        pulumi.Any(dataExchange.Project),
			Location:       pulumi.Any(dataExchange.Location),
			DataExchangeId: pulumi.Any(dataExchange.DataExchangeId),
			Role:           pulumi.String("roles/viewer"),
			Member:         pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

For all import syntaxes, the "resource in question" can take any of the following forms:

* projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}}

* {{project}}/{{location}}/{{data_exchange_id}}

* {{location}}/{{data_exchange_id}}

* {{data_exchange_id}}

Any variables not passed in the import command will be taken from the provider configuration.

Bigquery Analytics Hub dataexchange IAM resources can be imported using the resource identifiers, role, and member.

IAM member imports use space-delimited identifiers: the resource in question, the role, and the member identity, e.g.

```sh $ pulumi import gcp:bigqueryanalyticshub/dataExchangeIamPolicy:DataExchangeIamPolicy editor "projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}} roles/viewer user:jane@example.com" ```

IAM binding imports use space-delimited identifiers: the resource in question and the role, e.g.

```sh $ pulumi import gcp:bigqueryanalyticshub/dataExchangeIamPolicy:DataExchangeIamPolicy editor "projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}} roles/viewer" ```

IAM policy imports use the identifier of the resource in question, e.g.

```sh $ pulumi import gcp:bigqueryanalyticshub/dataExchangeIamPolicy:DataExchangeIamPolicy editor projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}} ```

-> **Custom Roles**: If you're importing a IAM resource with a custom role, make sure to use the 

full name of the custom role, e.g. `[projects/my-project|organizations/my-org]/roles/my-custom-role`.

func GetDataExchangeIamPolicy 

func GetDataExchangeIamPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *DataExchangeIamPolicyState, opts ...pulumi.ResourceOption) (*DataExchangeIamPolicy, error)

GetDataExchangeIamPolicy gets an existing DataExchangeIamPolicy resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewDataExchangeIamPolicy 

func NewDataExchangeIamPolicy(ctx *pulumi.Context,
	name string, args *DataExchangeIamPolicyArgs, opts ...pulumi.ResourceOption) (*DataExchangeIamPolicy, error)

NewDataExchangeIamPolicy registers a new resource with the given unique name, arguments, and options.

func (*DataExchangeIamPolicy) ElementType 

func (*DataExchangeIamPolicy) ElementType() reflect.Type

func (*DataExchangeIamPolicy) ToDataExchangeIamPolicyOutput 

func (i *DataExchangeIamPolicy) ToDataExchangeIamPolicyOutput() DataExchangeIamPolicyOutput

func (*DataExchangeIamPolicy) ToDataExchangeIamPolicyOutputWithContext 

func (i *DataExchangeIamPolicy) ToDataExchangeIamPolicyOutputWithContext(ctx context.Context) DataExchangeIamPolicyOutput

type DataExchangeIamPolicyArgs 

type DataExchangeIamPolicyArgs struct {
	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	DataExchangeId pulumi.StringInput
	// The name of the location this data exchange.
	// Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringPtrInput
	// The policy data generated by
	// a `organizations.getIAMPolicy` data source.
	PolicyData pulumi.StringInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
}

The set of arguments for constructing a DataExchangeIamPolicy resource.

func (DataExchangeIamPolicyArgs) ElementType 

func (DataExchangeIamPolicyArgs) ElementType() reflect.Type

type DataExchangeIamPolicyArray 

type DataExchangeIamPolicyArray []DataExchangeIamPolicyInput

func (DataExchangeIamPolicyArray) ElementType 

func (DataExchangeIamPolicyArray) ElementType() reflect.Type

func (DataExchangeIamPolicyArray) ToDataExchangeIamPolicyArrayOutput 

func (i DataExchangeIamPolicyArray) ToDataExchangeIamPolicyArrayOutput() DataExchangeIamPolicyArrayOutput

func (DataExchangeIamPolicyArray) ToDataExchangeIamPolicyArrayOutputWithContext 

func (i DataExchangeIamPolicyArray) ToDataExchangeIamPolicyArrayOutputWithContext(ctx context.Context) DataExchangeIamPolicyArrayOutput

type DataExchangeIamPolicyArrayInput 

type DataExchangeIamPolicyArrayInput interface {
	pulumi.Input

	ToDataExchangeIamPolicyArrayOutput() DataExchangeIamPolicyArrayOutput
	ToDataExchangeIamPolicyArrayOutputWithContext(context.Context) DataExchangeIamPolicyArrayOutput
}

DataExchangeIamPolicyArrayInput is an input type that accepts DataExchangeIamPolicyArray and DataExchangeIamPolicyArrayOutput values. You can construct a concrete instance of `DataExchangeIamPolicyArrayInput` via: 

DataExchangeIamPolicyArray{ DataExchangeIamPolicyArgs{...} }

type DataExchangeIamPolicyArrayOutput 

type DataExchangeIamPolicyArrayOutput struct{ *pulumi.OutputState }

func (DataExchangeIamPolicyArrayOutput) ElementType 

func (DataExchangeIamPolicyArrayOutput) ElementType() reflect.Type

func (DataExchangeIamPolicyArrayOutput) Index 

func (o DataExchangeIamPolicyArrayOutput) Index(i pulumi.IntInput) DataExchangeIamPolicyOutput

func (DataExchangeIamPolicyArrayOutput) ToDataExchangeIamPolicyArrayOutput 

func (o DataExchangeIamPolicyArrayOutput) ToDataExchangeIamPolicyArrayOutput() DataExchangeIamPolicyArrayOutput

func (DataExchangeIamPolicyArrayOutput) ToDataExchangeIamPolicyArrayOutputWithContext 

func (o DataExchangeIamPolicyArrayOutput) ToDataExchangeIamPolicyArrayOutputWithContext(ctx context.Context) DataExchangeIamPolicyArrayOutput

type DataExchangeIamPolicyInput 

type DataExchangeIamPolicyInput interface {
	pulumi.Input

	ToDataExchangeIamPolicyOutput() DataExchangeIamPolicyOutput
	ToDataExchangeIamPolicyOutputWithContext(ctx context.Context) DataExchangeIamPolicyOutput
}

type DataExchangeIamPolicyMap 

type DataExchangeIamPolicyMap map[string]DataExchangeIamPolicyInput

func (DataExchangeIamPolicyMap) ElementType 

func (DataExchangeIamPolicyMap) ElementType() reflect.Type

func (DataExchangeIamPolicyMap) ToDataExchangeIamPolicyMapOutput 

func (i DataExchangeIamPolicyMap) ToDataExchangeIamPolicyMapOutput() DataExchangeIamPolicyMapOutput

func (DataExchangeIamPolicyMap) ToDataExchangeIamPolicyMapOutputWithContext 

func (i DataExchangeIamPolicyMap) ToDataExchangeIamPolicyMapOutputWithContext(ctx context.Context) DataExchangeIamPolicyMapOutput

type DataExchangeIamPolicyMapInput 

type DataExchangeIamPolicyMapInput interface {
	pulumi.Input

	ToDataExchangeIamPolicyMapOutput() DataExchangeIamPolicyMapOutput
	ToDataExchangeIamPolicyMapOutputWithContext(context.Context) DataExchangeIamPolicyMapOutput
}

DataExchangeIamPolicyMapInput is an input type that accepts DataExchangeIamPolicyMap and DataExchangeIamPolicyMapOutput values. You can construct a concrete instance of `DataExchangeIamPolicyMapInput` via: 

DataExchangeIamPolicyMap{ "key": DataExchangeIamPolicyArgs{...} }

type DataExchangeIamPolicyMapOutput 

type DataExchangeIamPolicyMapOutput struct{ *pulumi.OutputState }

func (DataExchangeIamPolicyMapOutput) ElementType 

func (DataExchangeIamPolicyMapOutput) ElementType() reflect.Type

func (DataExchangeIamPolicyMapOutput) MapIndex 

func (o DataExchangeIamPolicyMapOutput) MapIndex(k pulumi.StringInput) DataExchangeIamPolicyOutput

func (DataExchangeIamPolicyMapOutput) ToDataExchangeIamPolicyMapOutput 

func (o DataExchangeIamPolicyMapOutput) ToDataExchangeIamPolicyMapOutput() DataExchangeIamPolicyMapOutput

func (DataExchangeIamPolicyMapOutput) ToDataExchangeIamPolicyMapOutputWithContext 

func (o DataExchangeIamPolicyMapOutput) ToDataExchangeIamPolicyMapOutputWithContext(ctx context.Context) DataExchangeIamPolicyMapOutput

type DataExchangeIamPolicyOutput 

type DataExchangeIamPolicyOutput struct{ *pulumi.OutputState }

func (DataExchangeIamPolicyOutput) DataExchangeId 

func (o DataExchangeIamPolicyOutput) DataExchangeId() pulumi.StringOutput

The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to

func (DataExchangeIamPolicyOutput) ElementType 

func (DataExchangeIamPolicyOutput) ElementType() reflect.Type

func (DataExchangeIamPolicyOutput) Etag 

func (o DataExchangeIamPolicyOutput) Etag() pulumi.StringOutput

(Computed) The etag of the IAM policy.

func (DataExchangeIamPolicyOutput) Location 

func (o DataExchangeIamPolicyOutput) Location() pulumi.StringOutput

The name of the location this data exchange. Used to find the parent resource to bind the IAM policy to

func (DataExchangeIamPolicyOutput) PolicyData 

func (o DataExchangeIamPolicyOutput) PolicyData() pulumi.StringOutput

The policy data generated by a `organizations.getIAMPolicy` data source.

func (DataExchangeIamPolicyOutput) Project 

func (o DataExchangeIamPolicyOutput) Project() pulumi.StringOutput

The ID of the project in which the resource belongs. If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.

func (DataExchangeIamPolicyOutput) ToDataExchangeIamPolicyOutput 

func (o DataExchangeIamPolicyOutput) ToDataExchangeIamPolicyOutput() DataExchangeIamPolicyOutput

func (DataExchangeIamPolicyOutput) ToDataExchangeIamPolicyOutputWithContext 

func (o DataExchangeIamPolicyOutput) ToDataExchangeIamPolicyOutputWithContext(ctx context.Context) DataExchangeIamPolicyOutput

type DataExchangeIamPolicyState 

type DataExchangeIamPolicyState struct {
	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	DataExchangeId pulumi.StringPtrInput
	// (Computed) The etag of the IAM policy.
	Etag pulumi.StringPtrInput
	// The name of the location this data exchange.
	// Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringPtrInput
	// The policy data generated by
	// a `organizations.getIAMPolicy` data source.
	PolicyData pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
}

func (DataExchangeIamPolicyState) ElementType 

func (DataExchangeIamPolicyState) ElementType() reflect.Type

type DataExchangeInput 

type DataExchangeInput interface {
	pulumi.Input

	ToDataExchangeOutput() DataExchangeOutput
	ToDataExchangeOutputWithContext(ctx context.Context) DataExchangeOutput
}

type DataExchangeMap 

type DataExchangeMap map[string]DataExchangeInput

func (DataExchangeMap) ElementType 

func (DataExchangeMap) ElementType() reflect.Type

func (DataExchangeMap) ToDataExchangeMapOutput 

func (i DataExchangeMap) ToDataExchangeMapOutput() DataExchangeMapOutput

func (DataExchangeMap) ToDataExchangeMapOutputWithContext 

func (i DataExchangeMap) ToDataExchangeMapOutputWithContext(ctx context.Context) DataExchangeMapOutput

type DataExchangeMapInput 

type DataExchangeMapInput interface {
	pulumi.Input

	ToDataExchangeMapOutput() DataExchangeMapOutput
	ToDataExchangeMapOutputWithContext(context.Context) DataExchangeMapOutput
}

DataExchangeMapInput is an input type that accepts DataExchangeMap and DataExchangeMapOutput values. You can construct a concrete instance of `DataExchangeMapInput` via: 

DataExchangeMap{ "key": DataExchangeArgs{...} }

type DataExchangeMapOutput 

type DataExchangeMapOutput struct{ *pulumi.OutputState }

func (DataExchangeMapOutput) ElementType 

func (DataExchangeMapOutput) ElementType() reflect.Type

func (DataExchangeMapOutput) MapIndex 

func (o DataExchangeMapOutput) MapIndex(k pulumi.StringInput) DataExchangeOutput

func (DataExchangeMapOutput) ToDataExchangeMapOutput 

func (o DataExchangeMapOutput) ToDataExchangeMapOutput() DataExchangeMapOutput

func (DataExchangeMapOutput) ToDataExchangeMapOutputWithContext 

func (o DataExchangeMapOutput) ToDataExchangeMapOutputWithContext(ctx context.Context) DataExchangeMapOutput

type DataExchangeOutput 

type DataExchangeOutput struct{ *pulumi.OutputState }

func (DataExchangeOutput) DataExchangeId 

func (o DataExchangeOutput) DataExchangeId() pulumi.StringOutput

The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces.

func (DataExchangeOutput) Description 

func (o DataExchangeOutput) Description() pulumi.StringPtrOutput

Description of the data exchange.

func (DataExchangeOutput) DisplayName 

func (o DataExchangeOutput) DisplayName() pulumi.StringOutput

Human-readable display name of the data exchange. The display name must contain only Unicode letters, numbers (0-9), underscores (_), dashes (-), spaces ( ), and must not start or end with spaces.

***

func (DataExchangeOutput) Documentation 

func (o DataExchangeOutput) Documentation() pulumi.StringPtrOutput

Documentation describing the data exchange.

func (DataExchangeOutput) ElementType 

func (DataExchangeOutput) ElementType() reflect.Type

func (DataExchangeOutput) Icon 

func (o DataExchangeOutput) Icon() pulumi.StringPtrOutput

Base64 encoded image representing the data exchange.

func (DataExchangeOutput) ListingCount 

func (o DataExchangeOutput) ListingCount() pulumi.IntOutput

Number of listings contained in the data exchange.

func (DataExchangeOutput) Location 

func (o DataExchangeOutput) Location() pulumi.StringOutput

The name of the location this data exchange.

func (DataExchangeOutput) Name 

func (o DataExchangeOutput) Name() pulumi.StringOutput

The resource name of the data exchange, for example: "projects/myproject/locations/US/dataExchanges/123"

func (DataExchangeOutput) PrimaryContact 

func (o DataExchangeOutput) PrimaryContact() pulumi.StringPtrOutput

Email or URL of the primary point of contact of the data exchange.

func (DataExchangeOutput) Project 

func (o DataExchangeOutput) Project() pulumi.StringOutput

The ID of the project in which the resource belongs. If it is not provided, the provider project is used.

func (DataExchangeOutput) ToDataExchangeOutput 

func (o DataExchangeOutput) ToDataExchangeOutput() DataExchangeOutput

func (DataExchangeOutput) ToDataExchangeOutputWithContext 

func (o DataExchangeOutput) ToDataExchangeOutputWithContext(ctx context.Context) DataExchangeOutput

type DataExchangeState 

type DataExchangeState struct {
	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces.
	DataExchangeId pulumi.StringPtrInput
	// Description of the data exchange.
	Description pulumi.StringPtrInput
	// Human-readable display name of the data exchange. The display name must contain only Unicode letters, numbers (0-9), underscores (_), dashes (-), spaces ( ), and must not start or end with spaces.
	//
	// ***
	DisplayName pulumi.StringPtrInput
	// Documentation describing the data exchange.
	Documentation pulumi.StringPtrInput
	// Base64 encoded image representing the data exchange.
	Icon pulumi.StringPtrInput
	// Number of listings contained in the data exchange.
	ListingCount pulumi.IntPtrInput
	// The name of the location this data exchange.
	Location pulumi.StringPtrInput
	// The resource name of the data exchange, for example:
	// "projects/myproject/locations/US/dataExchanges/123"
	Name pulumi.StringPtrInput
	// Email or URL of the primary point of contact of the data exchange.
	PrimaryContact pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the provider project is used.
	Project pulumi.StringPtrInput
}

func (DataExchangeState) ElementType 

func (DataExchangeState) ElementType() reflect.Type

type Listing 

type Listing struct {
	pulumi.CustomResourceState

	// Shared dataset i.e. BigQuery dataset source.
	// Structure is documented below.
	BigqueryDataset ListingBigqueryDatasetOutput `pulumi:"bigqueryDataset"`
	// Categories of the listing. Up to two categories are allowed.
	Categories pulumi.StringArrayOutput `pulumi:"categories"`
	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces.
	DataExchangeId pulumi.StringOutput `pulumi:"dataExchangeId"`
	// Details of the data provider who owns the source data.
	DataProvider ListingDataProviderPtrOutput `pulumi:"dataProvider"`
	// Short description of the listing. The description must not contain Unicode non-characters and C0 and C1 control codes
	// except tabs (HT), new lines (LF), carriage returns (CR), and page breaks (FF).
	Description pulumi.StringPtrOutput `pulumi:"description"`
	// Human-readable display name of the listing. The display name must contain only Unicode letters, numbers (0-9), underscores (_), dashes (-), spaces ( ), ampersands (&) and can't start or end with spaces.
	DisplayName pulumi.StringOutput `pulumi:"displayName"`
	// Documentation describing the listing.
	Documentation pulumi.StringPtrOutput `pulumi:"documentation"`
	// Base64 encoded image representing the listing.
	Icon pulumi.StringPtrOutput `pulumi:"icon"`
	// The ID of the listing. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces.
	ListingId pulumi.StringOutput `pulumi:"listingId"`
	// The name of the location this data exchange listing.
	Location pulumi.StringOutput `pulumi:"location"`
	// The resource name of the listing. e.g. "projects/myproject/locations/US/dataExchanges/123/listings/456"
	Name pulumi.StringOutput `pulumi:"name"`
	// Email or URL of the primary point of contact of the listing.
	PrimaryContact pulumi.StringPtrOutput `pulumi:"primaryContact"`
	Project        pulumi.StringOutput    `pulumi:"project"`
	// Details of the publisher who owns the listing and who can share the source data.
	Publisher ListingPublisherPtrOutput `pulumi:"publisher"`
	// Email or URL of the request access of the listing. Subscribers can use this reference to request access.
	RequestAccess pulumi.StringPtrOutput `pulumi:"requestAccess"`
	// If set, restricted export configuration will be propagated and enforced on the linked dataset.
	RestrictedExportConfig ListingRestrictedExportConfigPtrOutput `pulumi:"restrictedExportConfig"`
}

A Bigquery Analytics Hub data exchange listing

To get more information about Listing, see:

* [API documentation](https://cloud.google.com/bigquery/docs/reference/analytics-hub/rest/v1/projects.locations.dataExchanges.listings) * How-to Guides

## Example Usage

### Bigquery Analyticshub Listing Basic

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigquery"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		listing, err := bigqueryanalyticshub.NewDataExchange(ctx, "listing", &bigqueryanalyticshub.DataExchangeArgs{
			Location:       pulumi.String("US"),
			DataExchangeId: pulumi.String("my_data_exchange"),
			DisplayName:    pulumi.String("my_data_exchange"),
			Description:    pulumi.String("example data exchange"),
		})
		if err != nil {
			return err
		}
		listingDataset, err := bigquery.NewDataset(ctx, "listing", &bigquery.DatasetArgs{
			DatasetId:    pulumi.String("my_listing"),
			FriendlyName: pulumi.String("my_listing"),
			Description:  pulumi.String("example data exchange"),
			Location:     pulumi.String("US"),
		})
		if err != nil {
			return err
		}
		_, err = bigqueryanalyticshub.NewListing(ctx, "listing", &bigqueryanalyticshub.ListingArgs{
			Location:       pulumi.String("US"),
			DataExchangeId: listing.DataExchangeId,
			ListingId:      pulumi.String("my_listing"),
			DisplayName:    pulumi.String("my_listing"),
			Description:    pulumi.String("example data exchange"),
			BigqueryDataset: &bigqueryanalyticshub.ListingBigqueryDatasetArgs{
				Dataset: listingDataset.ID(),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

``` ### Bigquery Analyticshub Listing Restricted

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigquery"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		listing, err := bigqueryanalyticshub.NewDataExchange(ctx, "listing", &bigqueryanalyticshub.DataExchangeArgs{
			Location:       pulumi.String("US"),
			DataExchangeId: pulumi.String("my_data_exchange"),
			DisplayName:    pulumi.String("my_data_exchange"),
			Description:    pulumi.String("example data exchange"),
		})
		if err != nil {
			return err
		}
		listingDataset, err := bigquery.NewDataset(ctx, "listing", &bigquery.DatasetArgs{
			DatasetId:    pulumi.String("my_listing"),
			FriendlyName: pulumi.String("my_listing"),
			Description:  pulumi.String("example data exchange"),
			Location:     pulumi.String("US"),
		})
		if err != nil {
			return err
		}
		_, err = bigqueryanalyticshub.NewListing(ctx, "listing", &bigqueryanalyticshub.ListingArgs{
			Location:       pulumi.String("US"),
			DataExchangeId: listing.DataExchangeId,
			ListingId:      pulumi.String("my_listing"),
			DisplayName:    pulumi.String("my_listing"),
			Description:    pulumi.String("example data exchange"),
			BigqueryDataset: &bigqueryanalyticshub.ListingBigqueryDatasetArgs{
				Dataset: listingDataset.ID(),
			},
			RestrictedExportConfig: &bigqueryanalyticshub.ListingRestrictedExportConfigArgs{
				Enabled:             pulumi.Bool(true),
				RestrictQueryResult: pulumi.Bool(true),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

Listing can be imported using any of these accepted formats:

* `projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}}/listings/{{listing_id}}`

* `{{project}}/{{location}}/{{data_exchange_id}}/{{listing_id}}`

* `{{location}}/{{data_exchange_id}}/{{listing_id}}`

When using the `pulumi import` command, Listing can be imported using one of the formats above. For example:

```sh $ pulumi import gcp:bigqueryanalyticshub/listing:Listing default projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}}/listings/{{listing_id}} ```

```sh $ pulumi import gcp:bigqueryanalyticshub/listing:Listing default {{project}}/{{location}}/{{data_exchange_id}}/{{listing_id}} ```

```sh $ pulumi import gcp:bigqueryanalyticshub/listing:Listing default {{location}}/{{data_exchange_id}}/{{listing_id}} ```

func GetListing 

func GetListing(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ListingState, opts ...pulumi.ResourceOption) (*Listing, error)

GetListing gets an existing Listing resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewListing 

func NewListing(ctx *pulumi.Context,
	name string, args *ListingArgs, opts ...pulumi.ResourceOption) (*Listing, error)

NewListing registers a new resource with the given unique name, arguments, and options.

func (*Listing) ElementType 

func (*Listing) ElementType() reflect.Type

func (*Listing) ToListingOutput 

func (i *Listing) ToListingOutput() ListingOutput

func (*Listing) ToListingOutputWithContext 

func (i *Listing) ToListingOutputWithContext(ctx context.Context) ListingOutput

type ListingArgs 

type ListingArgs struct {
	// Shared dataset i.e. BigQuery dataset source.
	// Structure is documented below.
	BigqueryDataset ListingBigqueryDatasetInput
	// Categories of the listing. Up to two categories are allowed.
	Categories pulumi.StringArrayInput
	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces.
	DataExchangeId pulumi.StringInput
	// Details of the data provider who owns the source data.
	DataProvider ListingDataProviderPtrInput
	// Short description of the listing. The description must not contain Unicode non-characters and C0 and C1 control codes
	// except tabs (HT), new lines (LF), carriage returns (CR), and page breaks (FF).
	Description pulumi.StringPtrInput
	// Human-readable display name of the listing. The display name must contain only Unicode letters, numbers (0-9), underscores (_), dashes (-), spaces ( ), ampersands (&) and can't start or end with spaces.
	DisplayName pulumi.StringInput
	// Documentation describing the listing.
	Documentation pulumi.StringPtrInput
	// Base64 encoded image representing the listing.
	Icon pulumi.StringPtrInput
	// The ID of the listing. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces.
	ListingId pulumi.StringInput
	// The name of the location this data exchange listing.
	Location pulumi.StringInput
	// Email or URL of the primary point of contact of the listing.
	PrimaryContact pulumi.StringPtrInput
	Project        pulumi.StringPtrInput
	// Details of the publisher who owns the listing and who can share the source data.
	Publisher ListingPublisherPtrInput
	// Email or URL of the request access of the listing. Subscribers can use this reference to request access.
	RequestAccess pulumi.StringPtrInput
	// If set, restricted export configuration will be propagated and enforced on the linked dataset.
	RestrictedExportConfig ListingRestrictedExportConfigPtrInput
}

The set of arguments for constructing a Listing resource.

func (ListingArgs) ElementType 

func (ListingArgs) ElementType() reflect.Type

type ListingArray 

type ListingArray []ListingInput

func (ListingArray) ElementType 

func (ListingArray) ElementType() reflect.Type

func (ListingArray) ToListingArrayOutput 

func (i ListingArray) ToListingArrayOutput() ListingArrayOutput

func (ListingArray) ToListingArrayOutputWithContext 

func (i ListingArray) ToListingArrayOutputWithContext(ctx context.Context) ListingArrayOutput

type ListingArrayInput 

type ListingArrayInput interface {
	pulumi.Input

	ToListingArrayOutput() ListingArrayOutput
	ToListingArrayOutputWithContext(context.Context) ListingArrayOutput
}

ListingArrayInput is an input type that accepts ListingArray and ListingArrayOutput values. You can construct a concrete instance of `ListingArrayInput` via: 

ListingArray{ ListingArgs{...} }

type ListingArrayOutput 

type ListingArrayOutput struct{ *pulumi.OutputState }

func (ListingArrayOutput) ElementType 

func (ListingArrayOutput) ElementType() reflect.Type

func (ListingArrayOutput) Index 

func (o ListingArrayOutput) Index(i pulumi.IntInput) ListingOutput

func (ListingArrayOutput) ToListingArrayOutput 

func (o ListingArrayOutput) ToListingArrayOutput() ListingArrayOutput

func (ListingArrayOutput) ToListingArrayOutputWithContext 

func (o ListingArrayOutput) ToListingArrayOutputWithContext(ctx context.Context) ListingArrayOutput

type ListingBigqueryDataset 

type ListingBigqueryDataset struct {
	// Resource name of the dataset source for this listing. e.g. projects/myproject/datasets/123
	//
	// ***
	Dataset string `pulumi:"dataset"`
}

type ListingBigqueryDatasetArgs 

type ListingBigqueryDatasetArgs struct {
	// Resource name of the dataset source for this listing. e.g. projects/myproject/datasets/123
	//
	// ***
	Dataset pulumi.StringInput `pulumi:"dataset"`
}

func (ListingBigqueryDatasetArgs) ElementType 

func (ListingBigqueryDatasetArgs) ElementType() reflect.Type

func (ListingBigqueryDatasetArgs) ToListingBigqueryDatasetOutput 

func (i ListingBigqueryDatasetArgs) ToListingBigqueryDatasetOutput() ListingBigqueryDatasetOutput

func (ListingBigqueryDatasetArgs) ToListingBigqueryDatasetOutputWithContext 

func (i ListingBigqueryDatasetArgs) ToListingBigqueryDatasetOutputWithContext(ctx context.Context) ListingBigqueryDatasetOutput

func (ListingBigqueryDatasetArgs) ToListingBigqueryDatasetPtrOutput 

func (i ListingBigqueryDatasetArgs) ToListingBigqueryDatasetPtrOutput() ListingBigqueryDatasetPtrOutput

func (ListingBigqueryDatasetArgs) ToListingBigqueryDatasetPtrOutputWithContext 

func (i ListingBigqueryDatasetArgs) ToListingBigqueryDatasetPtrOutputWithContext(ctx context.Context) ListingBigqueryDatasetPtrOutput

type ListingBigqueryDatasetInput 

type ListingBigqueryDatasetInput interface {
	pulumi.Input

	ToListingBigqueryDatasetOutput() ListingBigqueryDatasetOutput
	ToListingBigqueryDatasetOutputWithContext(context.Context) ListingBigqueryDatasetOutput
}

ListingBigqueryDatasetInput is an input type that accepts ListingBigqueryDatasetArgs and ListingBigqueryDatasetOutput values. You can construct a concrete instance of `ListingBigqueryDatasetInput` via: 

ListingBigqueryDatasetArgs{...}

type ListingBigqueryDatasetOutput 

type ListingBigqueryDatasetOutput struct{ *pulumi.OutputState }

func (ListingBigqueryDatasetOutput) Dataset 

func (o ListingBigqueryDatasetOutput) Dataset() pulumi.StringOutput

Resource name of the dataset source for this listing. e.g. projects/myproject/datasets/123

***

func (ListingBigqueryDatasetOutput) ElementType 

func (ListingBigqueryDatasetOutput) ElementType() reflect.Type

func (ListingBigqueryDatasetOutput) ToListingBigqueryDatasetOutput 

func (o ListingBigqueryDatasetOutput) ToListingBigqueryDatasetOutput() ListingBigqueryDatasetOutput

func (ListingBigqueryDatasetOutput) ToListingBigqueryDatasetOutputWithContext 

func (o ListingBigqueryDatasetOutput) ToListingBigqueryDatasetOutputWithContext(ctx context.Context) ListingBigqueryDatasetOutput

func (ListingBigqueryDatasetOutput) ToListingBigqueryDatasetPtrOutput 

func (o ListingBigqueryDatasetOutput) ToListingBigqueryDatasetPtrOutput() ListingBigqueryDatasetPtrOutput

func (ListingBigqueryDatasetOutput) ToListingBigqueryDatasetPtrOutputWithContext 

func (o ListingBigqueryDatasetOutput) ToListingBigqueryDatasetPtrOutputWithContext(ctx context.Context) ListingBigqueryDatasetPtrOutput

type ListingBigqueryDatasetPtrInput 

type ListingBigqueryDatasetPtrInput interface {
	pulumi.Input

	ToListingBigqueryDatasetPtrOutput() ListingBigqueryDatasetPtrOutput
	ToListingBigqueryDatasetPtrOutputWithContext(context.Context) ListingBigqueryDatasetPtrOutput
}

ListingBigqueryDatasetPtrInput is an input type that accepts ListingBigqueryDatasetArgs, ListingBigqueryDatasetPtr and ListingBigqueryDatasetPtrOutput values. You can construct a concrete instance of `ListingBigqueryDatasetPtrInput` via: 

        ListingBigqueryDatasetArgs{...}

or:

        nil

func ListingBigqueryDatasetPtr 

func ListingBigqueryDatasetPtr(v *ListingBigqueryDatasetArgs) ListingBigqueryDatasetPtrInput

type ListingBigqueryDatasetPtrOutput 

type ListingBigqueryDatasetPtrOutput struct{ *pulumi.OutputState }

func (ListingBigqueryDatasetPtrOutput) Dataset 

func (o ListingBigqueryDatasetPtrOutput) Dataset() pulumi.StringPtrOutput

Resource name of the dataset source for this listing. e.g. projects/myproject/datasets/123

***

func (ListingBigqueryDatasetPtrOutput) Elem 

func (o ListingBigqueryDatasetPtrOutput) Elem() ListingBigqueryDatasetOutput

func (ListingBigqueryDatasetPtrOutput) ElementType 

func (ListingBigqueryDatasetPtrOutput) ElementType() reflect.Type

func (ListingBigqueryDatasetPtrOutput) ToListingBigqueryDatasetPtrOutput 

func (o ListingBigqueryDatasetPtrOutput) ToListingBigqueryDatasetPtrOutput() ListingBigqueryDatasetPtrOutput

func (ListingBigqueryDatasetPtrOutput) ToListingBigqueryDatasetPtrOutputWithContext 

func (o ListingBigqueryDatasetPtrOutput) ToListingBigqueryDatasetPtrOutputWithContext(ctx context.Context) ListingBigqueryDatasetPtrOutput

type ListingDataProvider 

type ListingDataProvider struct {
	// Name of the data provider.
	Name string `pulumi:"name"`
	// Email or URL of the data provider.
	PrimaryContact *string `pulumi:"primaryContact"`
}

type ListingDataProviderArgs 

type ListingDataProviderArgs struct {
	// Name of the data provider.
	Name pulumi.StringInput `pulumi:"name"`
	// Email or URL of the data provider.
	PrimaryContact pulumi.StringPtrInput `pulumi:"primaryContact"`
}

func (ListingDataProviderArgs) ElementType 

func (ListingDataProviderArgs) ElementType() reflect.Type

func (ListingDataProviderArgs) ToListingDataProviderOutput 

func (i ListingDataProviderArgs) ToListingDataProviderOutput() ListingDataProviderOutput

func (ListingDataProviderArgs) ToListingDataProviderOutputWithContext 

func (i ListingDataProviderArgs) ToListingDataProviderOutputWithContext(ctx context.Context) ListingDataProviderOutput

func (ListingDataProviderArgs) ToListingDataProviderPtrOutput 

func (i ListingDataProviderArgs) ToListingDataProviderPtrOutput() ListingDataProviderPtrOutput

func (ListingDataProviderArgs) ToListingDataProviderPtrOutputWithContext 

func (i ListingDataProviderArgs) ToListingDataProviderPtrOutputWithContext(ctx context.Context) ListingDataProviderPtrOutput

type ListingDataProviderInput 

type ListingDataProviderInput interface {
	pulumi.Input

	ToListingDataProviderOutput() ListingDataProviderOutput
	ToListingDataProviderOutputWithContext(context.Context) ListingDataProviderOutput
}

ListingDataProviderInput is an input type that accepts ListingDataProviderArgs and ListingDataProviderOutput values. You can construct a concrete instance of `ListingDataProviderInput` via: 

ListingDataProviderArgs{...}

type ListingDataProviderOutput 

type ListingDataProviderOutput struct{ *pulumi.OutputState }

func (ListingDataProviderOutput) ElementType 

func (ListingDataProviderOutput) ElementType() reflect.Type

func (ListingDataProviderOutput) Name 

func (o ListingDataProviderOutput) Name() pulumi.StringOutput

Name of the data provider.

func (ListingDataProviderOutput) PrimaryContact 

func (o ListingDataProviderOutput) PrimaryContact() pulumi.StringPtrOutput

Email or URL of the data provider.

func (ListingDataProviderOutput) ToListingDataProviderOutput 

func (o ListingDataProviderOutput) ToListingDataProviderOutput() ListingDataProviderOutput

func (ListingDataProviderOutput) ToListingDataProviderOutputWithContext 

func (o ListingDataProviderOutput) ToListingDataProviderOutputWithContext(ctx context.Context) ListingDataProviderOutput

func (ListingDataProviderOutput) ToListingDataProviderPtrOutput 

func (o ListingDataProviderOutput) ToListingDataProviderPtrOutput() ListingDataProviderPtrOutput

func (ListingDataProviderOutput) ToListingDataProviderPtrOutputWithContext 

func (o ListingDataProviderOutput) ToListingDataProviderPtrOutputWithContext(ctx context.Context) ListingDataProviderPtrOutput

type ListingDataProviderPtrInput 

type ListingDataProviderPtrInput interface {
	pulumi.Input

	ToListingDataProviderPtrOutput() ListingDataProviderPtrOutput
	ToListingDataProviderPtrOutputWithContext(context.Context) ListingDataProviderPtrOutput
}

ListingDataProviderPtrInput is an input type that accepts ListingDataProviderArgs, ListingDataProviderPtr and ListingDataProviderPtrOutput values. You can construct a concrete instance of `ListingDataProviderPtrInput` via: 

        ListingDataProviderArgs{...}

or:

        nil

func ListingDataProviderPtr 

func ListingDataProviderPtr(v *ListingDataProviderArgs) ListingDataProviderPtrInput

type ListingDataProviderPtrOutput 

type ListingDataProviderPtrOutput struct{ *pulumi.OutputState }

func (ListingDataProviderPtrOutput) Elem 

func (o ListingDataProviderPtrOutput) Elem() ListingDataProviderOutput

func (ListingDataProviderPtrOutput) ElementType 

func (ListingDataProviderPtrOutput) ElementType() reflect.Type

func (ListingDataProviderPtrOutput) Name 

func (o ListingDataProviderPtrOutput) Name() pulumi.StringPtrOutput

Name of the data provider.

func (ListingDataProviderPtrOutput) PrimaryContact 

func (o ListingDataProviderPtrOutput) PrimaryContact() pulumi.StringPtrOutput

Email or URL of the data provider.

func (ListingDataProviderPtrOutput) ToListingDataProviderPtrOutput 

func (o ListingDataProviderPtrOutput) ToListingDataProviderPtrOutput() ListingDataProviderPtrOutput

func (ListingDataProviderPtrOutput) ToListingDataProviderPtrOutputWithContext 

func (o ListingDataProviderPtrOutput) ToListingDataProviderPtrOutputWithContext(ctx context.Context) ListingDataProviderPtrOutput

type ListingIamBinding 

type ListingIamBinding struct {
	pulumi.CustomResourceState

	Condition ListingIamBindingConditionPtrOutput `pulumi:"condition"`
	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	DataExchangeId pulumi.StringOutput `pulumi:"dataExchangeId"`
	// (Computed) The etag of the IAM policy.
	Etag pulumi.StringOutput `pulumi:"etag"`
	// The ID of the listing. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	ListingId pulumi.StringOutput `pulumi:"listingId"`
	// The name of the location this data exchange listing.
	// Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringOutput `pulumi:"location"`
	// Identities that will be granted the privilege in `role`.
	// Each entry can have one of the following values:
	// * **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account.
	// * **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account.
	// * **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com.
	// * **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com.
	// * **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com.
	// * **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com.
	// * **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project"
	// * **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project"
	// * **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"
	Members pulumi.StringArrayOutput `pulumi:"members"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
	// The role that should be applied. Only one
	// `bigqueryanalyticshub.ListingIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringOutput `pulumi:"role"`
}

Three different resources help you manage your IAM policy for Bigquery Analytics Hub Listing. Each of these resources serves a different use case:

* `bigqueryanalyticshub.ListingIamPolicy`: Authoritative. Sets the IAM policy for the listing and replaces any existing policy already attached. * `bigqueryanalyticshub.ListingIamBinding`: Authoritative for a given role. Updates the IAM policy to grant a role to a list of members. Other roles within the IAM policy for the listing are preserved. * `bigqueryanalyticshub.ListingIamMember`: Non-authoritative. Updates the IAM policy to grant a role to a new member. Other members for the role for the listing are preserved.

A data source can be used to retrieve policy data in advent you do not need creation

* `bigqueryanalyticshub.ListingIamPolicy`: Retrieves the IAM policy for the listing

> **Note:** `bigqueryanalyticshub.ListingIamPolicy` **cannot** be used in conjunction with `bigqueryanalyticshub.ListingIamBinding` and `bigqueryanalyticshub.ListingIamMember` or they will fight over what your policy should be.

> **Note:** `bigqueryanalyticshub.ListingIamBinding` resources **can be** used in conjunction with `bigqueryanalyticshub.ListingIamMember` resources **only if** they do not grant privilege to the same role.

## google\_bigquery\_analytics\_hub\_listing\_iam\_policy

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				{
					Role: "roles/viewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = bigqueryanalyticshub.NewListingIamPolicy(ctx, "policy", &bigqueryanalyticshub.ListingIamPolicyArgs{
			Project:        pulumi.Any(listing.Project),
			Location:       pulumi.Any(listing.Location),
			DataExchangeId: pulumi.Any(listing.DataExchangeId),
			ListingId:      pulumi.Any(listing.ListingId),
			PolicyData:     pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_listing\_iam\_binding

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.NewListingIamBinding(ctx, "binding", &bigqueryanalyticshub.ListingIamBindingArgs{
			Project:        pulumi.Any(listing.Project),
			Location:       pulumi.Any(listing.Location),
			DataExchangeId: pulumi.Any(listing.DataExchangeId),
			ListingId:      pulumi.Any(listing.ListingId),
			Role:           pulumi.String("roles/viewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_listing\_iam\_member

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.NewListingIamMember(ctx, "member", &bigqueryanalyticshub.ListingIamMemberArgs{
			Project:        pulumi.Any(listing.Project),
			Location:       pulumi.Any(listing.Location),
			DataExchangeId: pulumi.Any(listing.DataExchangeId),
			ListingId:      pulumi.Any(listing.ListingId),
			Role:           pulumi.String("roles/viewer"),
			Member:         pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_listing\_iam\_policy

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				{
					Role: "roles/viewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = bigqueryanalyticshub.NewListingIamPolicy(ctx, "policy", &bigqueryanalyticshub.ListingIamPolicyArgs{
			Project:        pulumi.Any(listing.Project),
			Location:       pulumi.Any(listing.Location),
			DataExchangeId: pulumi.Any(listing.DataExchangeId),
			ListingId:      pulumi.Any(listing.ListingId),
			PolicyData:     pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_listing\_iam\_binding

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.NewListingIamBinding(ctx, "binding", &bigqueryanalyticshub.ListingIamBindingArgs{
			Project:        pulumi.Any(listing.Project),
			Location:       pulumi.Any(listing.Location),
			DataExchangeId: pulumi.Any(listing.DataExchangeId),
			ListingId:      pulumi.Any(listing.ListingId),
			Role:           pulumi.String("roles/viewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_listing\_iam\_member

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.NewListingIamMember(ctx, "member", &bigqueryanalyticshub.ListingIamMemberArgs{
			Project:        pulumi.Any(listing.Project),
			Location:       pulumi.Any(listing.Location),
			DataExchangeId: pulumi.Any(listing.DataExchangeId),
			ListingId:      pulumi.Any(listing.ListingId),
			Role:           pulumi.String("roles/viewer"),
			Member:         pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

For all import syntaxes, the "resource in question" can take any of the following forms:

* projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}}/listings/{{listing_id}}

* {{project}}/{{location}}/{{data_exchange_id}}/{{listing_id}}

* {{location}}/{{data_exchange_id}}/{{listing_id}}

* {{listing_id}}

Any variables not passed in the import command will be taken from the provider configuration.

Bigquery Analytics Hub listing IAM resources can be imported using the resource identifiers, role, and member.

IAM member imports use space-delimited identifiers: the resource in question, the role, and the member identity, e.g.

```sh $ pulumi import gcp:bigqueryanalyticshub/listingIamBinding:ListingIamBinding editor "projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}}/listings/{{listing_id}} roles/viewer user:jane@example.com" ```

IAM binding imports use space-delimited identifiers: the resource in question and the role, e.g.

```sh $ pulumi import gcp:bigqueryanalyticshub/listingIamBinding:ListingIamBinding editor "projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}}/listings/{{listing_id}} roles/viewer" ```

IAM policy imports use the identifier of the resource in question, e.g.

```sh $ pulumi import gcp:bigqueryanalyticshub/listingIamBinding:ListingIamBinding editor projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}}/listings/{{listing_id}} ```

-> **Custom Roles**: If you're importing a IAM resource with a custom role, make sure to use the 

full name of the custom role, e.g. `[projects/my-project|organizations/my-org]/roles/my-custom-role`.

func GetListingIamBinding 

func GetListingIamBinding(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ListingIamBindingState, opts ...pulumi.ResourceOption) (*ListingIamBinding, error)

GetListingIamBinding gets an existing ListingIamBinding resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewListingIamBinding 

func NewListingIamBinding(ctx *pulumi.Context,
	name string, args *ListingIamBindingArgs, opts ...pulumi.ResourceOption) (*ListingIamBinding, error)

NewListingIamBinding registers a new resource with the given unique name, arguments, and options.

func (*ListingIamBinding) ElementType 

func (*ListingIamBinding) ElementType() reflect.Type

func (*ListingIamBinding) ToListingIamBindingOutput 

func (i *ListingIamBinding) ToListingIamBindingOutput() ListingIamBindingOutput

func (*ListingIamBinding) ToListingIamBindingOutputWithContext 

func (i *ListingIamBinding) ToListingIamBindingOutputWithContext(ctx context.Context) ListingIamBindingOutput

type ListingIamBindingArgs 

type ListingIamBindingArgs struct {
	Condition ListingIamBindingConditionPtrInput
	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	DataExchangeId pulumi.StringInput
	// The ID of the listing. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	ListingId pulumi.StringInput
	// The name of the location this data exchange listing.
	// Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringPtrInput
	// Identities that will be granted the privilege in `role`.
	// Each entry can have one of the following values:
	// * **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account.
	// * **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account.
	// * **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com.
	// * **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com.
	// * **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com.
	// * **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com.
	// * **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project"
	// * **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project"
	// * **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"
	Members pulumi.StringArrayInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
	// The role that should be applied. Only one
	// `bigqueryanalyticshub.ListingIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringInput
}

The set of arguments for constructing a ListingIamBinding resource.

func (ListingIamBindingArgs) ElementType 

func (ListingIamBindingArgs) ElementType() reflect.Type

type ListingIamBindingArray 

type ListingIamBindingArray []ListingIamBindingInput

func (ListingIamBindingArray) ElementType 

func (ListingIamBindingArray) ElementType() reflect.Type

func (ListingIamBindingArray) ToListingIamBindingArrayOutput 

func (i ListingIamBindingArray) ToListingIamBindingArrayOutput() ListingIamBindingArrayOutput

func (ListingIamBindingArray) ToListingIamBindingArrayOutputWithContext 

func (i ListingIamBindingArray) ToListingIamBindingArrayOutputWithContext(ctx context.Context) ListingIamBindingArrayOutput

type ListingIamBindingArrayInput 

type ListingIamBindingArrayInput interface {
	pulumi.Input

	ToListingIamBindingArrayOutput() ListingIamBindingArrayOutput
	ToListingIamBindingArrayOutputWithContext(context.Context) ListingIamBindingArrayOutput
}

ListingIamBindingArrayInput is an input type that accepts ListingIamBindingArray and ListingIamBindingArrayOutput values. You can construct a concrete instance of `ListingIamBindingArrayInput` via: 

ListingIamBindingArray{ ListingIamBindingArgs{...} }

type ListingIamBindingArrayOutput 

type ListingIamBindingArrayOutput struct{ *pulumi.OutputState }

func (ListingIamBindingArrayOutput) ElementType 

func (ListingIamBindingArrayOutput) ElementType() reflect.Type

func (ListingIamBindingArrayOutput) Index 

func (o ListingIamBindingArrayOutput) Index(i pulumi.IntInput) ListingIamBindingOutput

func (ListingIamBindingArrayOutput) ToListingIamBindingArrayOutput 

func (o ListingIamBindingArrayOutput) ToListingIamBindingArrayOutput() ListingIamBindingArrayOutput

func (ListingIamBindingArrayOutput) ToListingIamBindingArrayOutputWithContext 

func (o ListingIamBindingArrayOutput) ToListingIamBindingArrayOutputWithContext(ctx context.Context) ListingIamBindingArrayOutput

type ListingIamBindingCondition 

type ListingIamBindingCondition struct {
	Description *string `pulumi:"description"`
	Expression  string  `pulumi:"expression"`
	Title       string  `pulumi:"title"`
}

type ListingIamBindingConditionArgs 

type ListingIamBindingConditionArgs struct {
	Description pulumi.StringPtrInput `pulumi:"description"`
	Expression  pulumi.StringInput    `pulumi:"expression"`
	Title       pulumi.StringInput    `pulumi:"title"`
}

func (ListingIamBindingConditionArgs) ElementType 

func (ListingIamBindingConditionArgs) ElementType() reflect.Type

func (ListingIamBindingConditionArgs) ToListingIamBindingConditionOutput 

func (i ListingIamBindingConditionArgs) ToListingIamBindingConditionOutput() ListingIamBindingConditionOutput

func (ListingIamBindingConditionArgs) ToListingIamBindingConditionOutputWithContext 

func (i ListingIamBindingConditionArgs) ToListingIamBindingConditionOutputWithContext(ctx context.Context) ListingIamBindingConditionOutput

func (ListingIamBindingConditionArgs) ToListingIamBindingConditionPtrOutput 

func (i ListingIamBindingConditionArgs) ToListingIamBindingConditionPtrOutput() ListingIamBindingConditionPtrOutput

func (ListingIamBindingConditionArgs) ToListingIamBindingConditionPtrOutputWithContext 

func (i ListingIamBindingConditionArgs) ToListingIamBindingConditionPtrOutputWithContext(ctx context.Context) ListingIamBindingConditionPtrOutput

type ListingIamBindingConditionInput 

type ListingIamBindingConditionInput interface {
	pulumi.Input

	ToListingIamBindingConditionOutput() ListingIamBindingConditionOutput
	ToListingIamBindingConditionOutputWithContext(context.Context) ListingIamBindingConditionOutput
}

ListingIamBindingConditionInput is an input type that accepts ListingIamBindingConditionArgs and ListingIamBindingConditionOutput values. You can construct a concrete instance of `ListingIamBindingConditionInput` via: 

ListingIamBindingConditionArgs{...}

type ListingIamBindingConditionOutput 

type ListingIamBindingConditionOutput struct{ *pulumi.OutputState }

func (ListingIamBindingConditionOutput) Description 

func (o ListingIamBindingConditionOutput) Description() pulumi.StringPtrOutput

func (ListingIamBindingConditionOutput) ElementType 

func (ListingIamBindingConditionOutput) ElementType() reflect.Type

func (ListingIamBindingConditionOutput) Expression 

func (o ListingIamBindingConditionOutput) Expression() pulumi.StringOutput

func (ListingIamBindingConditionOutput) Title 

func (o ListingIamBindingConditionOutput) Title() pulumi.StringOutput

func (ListingIamBindingConditionOutput) ToListingIamBindingConditionOutput 

func (o ListingIamBindingConditionOutput) ToListingIamBindingConditionOutput() ListingIamBindingConditionOutput

func (ListingIamBindingConditionOutput) ToListingIamBindingConditionOutputWithContext 

func (o ListingIamBindingConditionOutput) ToListingIamBindingConditionOutputWithContext(ctx context.Context) ListingIamBindingConditionOutput

func (ListingIamBindingConditionOutput) ToListingIamBindingConditionPtrOutput 

func (o ListingIamBindingConditionOutput) ToListingIamBindingConditionPtrOutput() ListingIamBindingConditionPtrOutput

func (ListingIamBindingConditionOutput) ToListingIamBindingConditionPtrOutputWithContext 

func (o ListingIamBindingConditionOutput) ToListingIamBindingConditionPtrOutputWithContext(ctx context.Context) ListingIamBindingConditionPtrOutput

type ListingIamBindingConditionPtrInput 

type ListingIamBindingConditionPtrInput interface {
	pulumi.Input

	ToListingIamBindingConditionPtrOutput() ListingIamBindingConditionPtrOutput
	ToListingIamBindingConditionPtrOutputWithContext(context.Context) ListingIamBindingConditionPtrOutput
}

ListingIamBindingConditionPtrInput is an input type that accepts ListingIamBindingConditionArgs, ListingIamBindingConditionPtr and ListingIamBindingConditionPtrOutput values. You can construct a concrete instance of `ListingIamBindingConditionPtrInput` via: 

        ListingIamBindingConditionArgs{...}

or:

        nil

func ListingIamBindingConditionPtr 

func ListingIamBindingConditionPtr(v *ListingIamBindingConditionArgs) ListingIamBindingConditionPtrInput

type ListingIamBindingConditionPtrOutput 

type ListingIamBindingConditionPtrOutput struct{ *pulumi.OutputState }

func (ListingIamBindingConditionPtrOutput) Description 

func (o ListingIamBindingConditionPtrOutput) Description() pulumi.StringPtrOutput

func (ListingIamBindingConditionPtrOutput) Elem 

func (o ListingIamBindingConditionPtrOutput) Elem() ListingIamBindingConditionOutput

func (ListingIamBindingConditionPtrOutput) ElementType 

func (ListingIamBindingConditionPtrOutput) ElementType() reflect.Type

func (ListingIamBindingConditionPtrOutput) Expression 

func (o ListingIamBindingConditionPtrOutput) Expression() pulumi.StringPtrOutput

func (ListingIamBindingConditionPtrOutput) Title 

func (o ListingIamBindingConditionPtrOutput) Title() pulumi.StringPtrOutput

func (ListingIamBindingConditionPtrOutput) ToListingIamBindingConditionPtrOutput 

func (o ListingIamBindingConditionPtrOutput) ToListingIamBindingConditionPtrOutput() ListingIamBindingConditionPtrOutput

func (ListingIamBindingConditionPtrOutput) ToListingIamBindingConditionPtrOutputWithContext 

func (o ListingIamBindingConditionPtrOutput) ToListingIamBindingConditionPtrOutputWithContext(ctx context.Context) ListingIamBindingConditionPtrOutput

type ListingIamBindingInput 

type ListingIamBindingInput interface {
	pulumi.Input

	ToListingIamBindingOutput() ListingIamBindingOutput
	ToListingIamBindingOutputWithContext(ctx context.Context) ListingIamBindingOutput
}

type ListingIamBindingMap 

type ListingIamBindingMap map[string]ListingIamBindingInput

func (ListingIamBindingMap) ElementType 

func (ListingIamBindingMap) ElementType() reflect.Type

func (ListingIamBindingMap) ToListingIamBindingMapOutput 

func (i ListingIamBindingMap) ToListingIamBindingMapOutput() ListingIamBindingMapOutput

func (ListingIamBindingMap) ToListingIamBindingMapOutputWithContext 

func (i ListingIamBindingMap) ToListingIamBindingMapOutputWithContext(ctx context.Context) ListingIamBindingMapOutput

type ListingIamBindingMapInput 

type ListingIamBindingMapInput interface {
	pulumi.Input

	ToListingIamBindingMapOutput() ListingIamBindingMapOutput
	ToListingIamBindingMapOutputWithContext(context.Context) ListingIamBindingMapOutput
}

ListingIamBindingMapInput is an input type that accepts ListingIamBindingMap and ListingIamBindingMapOutput values. You can construct a concrete instance of `ListingIamBindingMapInput` via: 

ListingIamBindingMap{ "key": ListingIamBindingArgs{...} }

type ListingIamBindingMapOutput 

type ListingIamBindingMapOutput struct{ *pulumi.OutputState }

func (ListingIamBindingMapOutput) ElementType 

func (ListingIamBindingMapOutput) ElementType() reflect.Type

func (ListingIamBindingMapOutput) MapIndex 

func (o ListingIamBindingMapOutput) MapIndex(k pulumi.StringInput) ListingIamBindingOutput

func (ListingIamBindingMapOutput) ToListingIamBindingMapOutput 

func (o ListingIamBindingMapOutput) ToListingIamBindingMapOutput() ListingIamBindingMapOutput

func (ListingIamBindingMapOutput) ToListingIamBindingMapOutputWithContext 

func (o ListingIamBindingMapOutput) ToListingIamBindingMapOutputWithContext(ctx context.Context) ListingIamBindingMapOutput

type ListingIamBindingOutput 

type ListingIamBindingOutput struct{ *pulumi.OutputState }

func (ListingIamBindingOutput) Condition 

func (o ListingIamBindingOutput) Condition() ListingIamBindingConditionPtrOutput

func (ListingIamBindingOutput) DataExchangeId 

func (o ListingIamBindingOutput) DataExchangeId() pulumi.StringOutput

The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to

func (ListingIamBindingOutput) ElementType 

func (ListingIamBindingOutput) ElementType() reflect.Type

func (ListingIamBindingOutput) Etag 

func (o ListingIamBindingOutput) Etag() pulumi.StringOutput

(Computed) The etag of the IAM policy.

func (ListingIamBindingOutput) ListingId 

func (o ListingIamBindingOutput) ListingId() pulumi.StringOutput

The ID of the listing. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to

func (ListingIamBindingOutput) Location 

func (o ListingIamBindingOutput) Location() pulumi.StringOutput

The name of the location this data exchange listing. Used to find the parent resource to bind the IAM policy to

func (ListingIamBindingOutput) Members 

func (o ListingIamBindingOutput) Members() pulumi.StringArrayOutput

Identities that will be granted the privilege in `role`. Each entry can have one of the following values: * **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account. * **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account. * **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com. * **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com. * **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com. * **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com. * **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project" * **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project" * **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"

func (ListingIamBindingOutput) Project 

func (o ListingIamBindingOutput) Project() pulumi.StringOutput

The ID of the project in which the resource belongs. If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.

func (ListingIamBindingOutput) Role 

func (o ListingIamBindingOutput) Role() pulumi.StringOutput

The role that should be applied. Only one `bigqueryanalyticshub.ListingIamBinding` can be used per role. Note that custom roles must be of the format `[projects|organizations]/{parent-name}/roles/{role-name}`.

func (ListingIamBindingOutput) ToListingIamBindingOutput 

func (o ListingIamBindingOutput) ToListingIamBindingOutput() ListingIamBindingOutput

func (ListingIamBindingOutput) ToListingIamBindingOutputWithContext 

func (o ListingIamBindingOutput) ToListingIamBindingOutputWithContext(ctx context.Context) ListingIamBindingOutput

type ListingIamBindingState 

type ListingIamBindingState struct {
	Condition ListingIamBindingConditionPtrInput
	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	DataExchangeId pulumi.StringPtrInput
	// (Computed) The etag of the IAM policy.
	Etag pulumi.StringPtrInput
	// The ID of the listing. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	ListingId pulumi.StringPtrInput
	// The name of the location this data exchange listing.
	// Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringPtrInput
	// Identities that will be granted the privilege in `role`.
	// Each entry can have one of the following values:
	// * **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account.
	// * **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account.
	// * **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com.
	// * **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com.
	// * **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com.
	// * **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com.
	// * **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project"
	// * **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project"
	// * **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"
	Members pulumi.StringArrayInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
	// The role that should be applied. Only one
	// `bigqueryanalyticshub.ListingIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringPtrInput
}

func (ListingIamBindingState) ElementType 

func (ListingIamBindingState) ElementType() reflect.Type

type ListingIamMember 

type ListingIamMember struct {
	pulumi.CustomResourceState

	Condition ListingIamMemberConditionPtrOutput `pulumi:"condition"`
	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	DataExchangeId pulumi.StringOutput `pulumi:"dataExchangeId"`
	// (Computed) The etag of the IAM policy.
	Etag pulumi.StringOutput `pulumi:"etag"`
	// The ID of the listing. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	ListingId pulumi.StringOutput `pulumi:"listingId"`
	// The name of the location this data exchange listing.
	// Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringOutput `pulumi:"location"`
	// Identities that will be granted the privilege in `role`.
	// Each entry can have one of the following values:
	// * **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account.
	// * **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account.
	// * **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com.
	// * **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com.
	// * **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com.
	// * **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com.
	// * **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project"
	// * **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project"
	// * **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"
	Member pulumi.StringOutput `pulumi:"member"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
	// The role that should be applied. Only one
	// `bigqueryanalyticshub.ListingIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringOutput `pulumi:"role"`
}

Three different resources help you manage your IAM policy for Bigquery Analytics Hub Listing. Each of these resources serves a different use case:

* `bigqueryanalyticshub.ListingIamPolicy`: Authoritative. Sets the IAM policy for the listing and replaces any existing policy already attached. * `bigqueryanalyticshub.ListingIamBinding`: Authoritative for a given role. Updates the IAM policy to grant a role to a list of members. Other roles within the IAM policy for the listing are preserved. * `bigqueryanalyticshub.ListingIamMember`: Non-authoritative. Updates the IAM policy to grant a role to a new member. Other members for the role for the listing are preserved.

A data source can be used to retrieve policy data in advent you do not need creation

* `bigqueryanalyticshub.ListingIamPolicy`: Retrieves the IAM policy for the listing

> **Note:** `bigqueryanalyticshub.ListingIamPolicy` **cannot** be used in conjunction with `bigqueryanalyticshub.ListingIamBinding` and `bigqueryanalyticshub.ListingIamMember` or they will fight over what your policy should be.

> **Note:** `bigqueryanalyticshub.ListingIamBinding` resources **can be** used in conjunction with `bigqueryanalyticshub.ListingIamMember` resources **only if** they do not grant privilege to the same role.

## google\_bigquery\_analytics\_hub\_listing\_iam\_policy

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				{
					Role: "roles/viewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = bigqueryanalyticshub.NewListingIamPolicy(ctx, "policy", &bigqueryanalyticshub.ListingIamPolicyArgs{
			Project:        pulumi.Any(listing.Project),
			Location:       pulumi.Any(listing.Location),
			DataExchangeId: pulumi.Any(listing.DataExchangeId),
			ListingId:      pulumi.Any(listing.ListingId),
			PolicyData:     pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_listing\_iam\_binding

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.NewListingIamBinding(ctx, "binding", &bigqueryanalyticshub.ListingIamBindingArgs{
			Project:        pulumi.Any(listing.Project),
			Location:       pulumi.Any(listing.Location),
			DataExchangeId: pulumi.Any(listing.DataExchangeId),
			ListingId:      pulumi.Any(listing.ListingId),
			Role:           pulumi.String("roles/viewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_listing\_iam\_member

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.NewListingIamMember(ctx, "member", &bigqueryanalyticshub.ListingIamMemberArgs{
			Project:        pulumi.Any(listing.Project),
			Location:       pulumi.Any(listing.Location),
			DataExchangeId: pulumi.Any(listing.DataExchangeId),
			ListingId:      pulumi.Any(listing.ListingId),
			Role:           pulumi.String("roles/viewer"),
			Member:         pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_listing\_iam\_policy

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				{
					Role: "roles/viewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = bigqueryanalyticshub.NewListingIamPolicy(ctx, "policy", &bigqueryanalyticshub.ListingIamPolicyArgs{
			Project:        pulumi.Any(listing.Project),
			Location:       pulumi.Any(listing.Location),
			DataExchangeId: pulumi.Any(listing.DataExchangeId),
			ListingId:      pulumi.Any(listing.ListingId),
			PolicyData:     pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_listing\_iam\_binding

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.NewListingIamBinding(ctx, "binding", &bigqueryanalyticshub.ListingIamBindingArgs{
			Project:        pulumi.Any(listing.Project),
			Location:       pulumi.Any(listing.Location),
			DataExchangeId: pulumi.Any(listing.DataExchangeId),
			ListingId:      pulumi.Any(listing.ListingId),
			Role:           pulumi.String("roles/viewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_listing\_iam\_member

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.NewListingIamMember(ctx, "member", &bigqueryanalyticshub.ListingIamMemberArgs{
			Project:        pulumi.Any(listing.Project),
			Location:       pulumi.Any(listing.Location),
			DataExchangeId: pulumi.Any(listing.DataExchangeId),
			ListingId:      pulumi.Any(listing.ListingId),
			Role:           pulumi.String("roles/viewer"),
			Member:         pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

For all import syntaxes, the "resource in question" can take any of the following forms:

* projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}}/listings/{{listing_id}}

* {{project}}/{{location}}/{{data_exchange_id}}/{{listing_id}}

* {{location}}/{{data_exchange_id}}/{{listing_id}}

* {{listing_id}}

Any variables not passed in the import command will be taken from the provider configuration.

Bigquery Analytics Hub listing IAM resources can be imported using the resource identifiers, role, and member.

IAM member imports use space-delimited identifiers: the resource in question, the role, and the member identity, e.g.

```sh $ pulumi import gcp:bigqueryanalyticshub/listingIamMember:ListingIamMember editor "projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}}/listings/{{listing_id}} roles/viewer user:jane@example.com" ```

IAM binding imports use space-delimited identifiers: the resource in question and the role, e.g.

```sh $ pulumi import gcp:bigqueryanalyticshub/listingIamMember:ListingIamMember editor "projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}}/listings/{{listing_id}} roles/viewer" ```

IAM policy imports use the identifier of the resource in question, e.g.

```sh $ pulumi import gcp:bigqueryanalyticshub/listingIamMember:ListingIamMember editor projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}}/listings/{{listing_id}} ```

-> **Custom Roles**: If you're importing a IAM resource with a custom role, make sure to use the 

full name of the custom role, e.g. `[projects/my-project|organizations/my-org]/roles/my-custom-role`.

func GetListingIamMember 

func GetListingIamMember(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ListingIamMemberState, opts ...pulumi.ResourceOption) (*ListingIamMember, error)

GetListingIamMember gets an existing ListingIamMember resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewListingIamMember 

func NewListingIamMember(ctx *pulumi.Context,
	name string, args *ListingIamMemberArgs, opts ...pulumi.ResourceOption) (*ListingIamMember, error)

NewListingIamMember registers a new resource with the given unique name, arguments, and options.

func (*ListingIamMember) ElementType 

func (*ListingIamMember) ElementType() reflect.Type

func (*ListingIamMember) ToListingIamMemberOutput 

func (i *ListingIamMember) ToListingIamMemberOutput() ListingIamMemberOutput

func (*ListingIamMember) ToListingIamMemberOutputWithContext 

func (i *ListingIamMember) ToListingIamMemberOutputWithContext(ctx context.Context) ListingIamMemberOutput

type ListingIamMemberArgs 

type ListingIamMemberArgs struct {
	Condition ListingIamMemberConditionPtrInput
	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	DataExchangeId pulumi.StringInput
	// The ID of the listing. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	ListingId pulumi.StringInput
	// The name of the location this data exchange listing.
	// Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringPtrInput
	// Identities that will be granted the privilege in `role`.
	// Each entry can have one of the following values:
	// * **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account.
	// * **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account.
	// * **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com.
	// * **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com.
	// * **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com.
	// * **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com.
	// * **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project"
	// * **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project"
	// * **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"
	Member pulumi.StringInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
	// The role that should be applied. Only one
	// `bigqueryanalyticshub.ListingIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringInput
}

The set of arguments for constructing a ListingIamMember resource.

func (ListingIamMemberArgs) ElementType 

func (ListingIamMemberArgs) ElementType() reflect.Type

type ListingIamMemberArray 

type ListingIamMemberArray []ListingIamMemberInput

func (ListingIamMemberArray) ElementType 

func (ListingIamMemberArray) ElementType() reflect.Type

func (ListingIamMemberArray) ToListingIamMemberArrayOutput 

func (i ListingIamMemberArray) ToListingIamMemberArrayOutput() ListingIamMemberArrayOutput

func (ListingIamMemberArray) ToListingIamMemberArrayOutputWithContext 

func (i ListingIamMemberArray) ToListingIamMemberArrayOutputWithContext(ctx context.Context) ListingIamMemberArrayOutput

type ListingIamMemberArrayInput 

type ListingIamMemberArrayInput interface {
	pulumi.Input

	ToListingIamMemberArrayOutput() ListingIamMemberArrayOutput
	ToListingIamMemberArrayOutputWithContext(context.Context) ListingIamMemberArrayOutput
}

ListingIamMemberArrayInput is an input type that accepts ListingIamMemberArray and ListingIamMemberArrayOutput values. You can construct a concrete instance of `ListingIamMemberArrayInput` via: 

ListingIamMemberArray{ ListingIamMemberArgs{...} }

type ListingIamMemberArrayOutput 

type ListingIamMemberArrayOutput struct{ *pulumi.OutputState }

func (ListingIamMemberArrayOutput) ElementType 

func (ListingIamMemberArrayOutput) ElementType() reflect.Type

func (ListingIamMemberArrayOutput) Index 

func (o ListingIamMemberArrayOutput) Index(i pulumi.IntInput) ListingIamMemberOutput

func (ListingIamMemberArrayOutput) ToListingIamMemberArrayOutput 

func (o ListingIamMemberArrayOutput) ToListingIamMemberArrayOutput() ListingIamMemberArrayOutput

func (ListingIamMemberArrayOutput) ToListingIamMemberArrayOutputWithContext 

func (o ListingIamMemberArrayOutput) ToListingIamMemberArrayOutputWithContext(ctx context.Context) ListingIamMemberArrayOutput

type ListingIamMemberCondition 

type ListingIamMemberCondition struct {
	Description *string `pulumi:"description"`
	Expression  string  `pulumi:"expression"`
	Title       string  `pulumi:"title"`
}

type ListingIamMemberConditionArgs 

type ListingIamMemberConditionArgs struct {
	Description pulumi.StringPtrInput `pulumi:"description"`
	Expression  pulumi.StringInput    `pulumi:"expression"`
	Title       pulumi.StringInput    `pulumi:"title"`
}

func (ListingIamMemberConditionArgs) ElementType 

func (ListingIamMemberConditionArgs) ElementType() reflect.Type

func (ListingIamMemberConditionArgs) ToListingIamMemberConditionOutput 

func (i ListingIamMemberConditionArgs) ToListingIamMemberConditionOutput() ListingIamMemberConditionOutput

func (ListingIamMemberConditionArgs) ToListingIamMemberConditionOutputWithContext 

func (i ListingIamMemberConditionArgs) ToListingIamMemberConditionOutputWithContext(ctx context.Context) ListingIamMemberConditionOutput

func (ListingIamMemberConditionArgs) ToListingIamMemberConditionPtrOutput 

func (i ListingIamMemberConditionArgs) ToListingIamMemberConditionPtrOutput() ListingIamMemberConditionPtrOutput

func (ListingIamMemberConditionArgs) ToListingIamMemberConditionPtrOutputWithContext 

func (i ListingIamMemberConditionArgs) ToListingIamMemberConditionPtrOutputWithContext(ctx context.Context) ListingIamMemberConditionPtrOutput

type ListingIamMemberConditionInput 

type ListingIamMemberConditionInput interface {
	pulumi.Input

	ToListingIamMemberConditionOutput() ListingIamMemberConditionOutput
	ToListingIamMemberConditionOutputWithContext(context.Context) ListingIamMemberConditionOutput
}

ListingIamMemberConditionInput is an input type that accepts ListingIamMemberConditionArgs and ListingIamMemberConditionOutput values. You can construct a concrete instance of `ListingIamMemberConditionInput` via: 

ListingIamMemberConditionArgs{...}

type ListingIamMemberConditionOutput 

type ListingIamMemberConditionOutput struct{ *pulumi.OutputState }

func (ListingIamMemberConditionOutput) Description 

func (o ListingIamMemberConditionOutput) Description() pulumi.StringPtrOutput

func (ListingIamMemberConditionOutput) ElementType 

func (ListingIamMemberConditionOutput) ElementType() reflect.Type

func (ListingIamMemberConditionOutput) Expression 

func (o ListingIamMemberConditionOutput) Expression() pulumi.StringOutput

func (ListingIamMemberConditionOutput) Title 

func (o ListingIamMemberConditionOutput) Title() pulumi.StringOutput

func (ListingIamMemberConditionOutput) ToListingIamMemberConditionOutput 

func (o ListingIamMemberConditionOutput) ToListingIamMemberConditionOutput() ListingIamMemberConditionOutput

func (ListingIamMemberConditionOutput) ToListingIamMemberConditionOutputWithContext 

func (o ListingIamMemberConditionOutput) ToListingIamMemberConditionOutputWithContext(ctx context.Context) ListingIamMemberConditionOutput

func (ListingIamMemberConditionOutput) ToListingIamMemberConditionPtrOutput 

func (o ListingIamMemberConditionOutput) ToListingIamMemberConditionPtrOutput() ListingIamMemberConditionPtrOutput

func (ListingIamMemberConditionOutput) ToListingIamMemberConditionPtrOutputWithContext 

func (o ListingIamMemberConditionOutput) ToListingIamMemberConditionPtrOutputWithContext(ctx context.Context) ListingIamMemberConditionPtrOutput

type ListingIamMemberConditionPtrInput 

type ListingIamMemberConditionPtrInput interface {
	pulumi.Input

	ToListingIamMemberConditionPtrOutput() ListingIamMemberConditionPtrOutput
	ToListingIamMemberConditionPtrOutputWithContext(context.Context) ListingIamMemberConditionPtrOutput
}

ListingIamMemberConditionPtrInput is an input type that accepts ListingIamMemberConditionArgs, ListingIamMemberConditionPtr and ListingIamMemberConditionPtrOutput values. You can construct a concrete instance of `ListingIamMemberConditionPtrInput` via: 

        ListingIamMemberConditionArgs{...}

or:

        nil

func ListingIamMemberConditionPtr 

func ListingIamMemberConditionPtr(v *ListingIamMemberConditionArgs) ListingIamMemberConditionPtrInput

type ListingIamMemberConditionPtrOutput 

type ListingIamMemberConditionPtrOutput struct{ *pulumi.OutputState }

func (ListingIamMemberConditionPtrOutput) Description 

func (o ListingIamMemberConditionPtrOutput) Description() pulumi.StringPtrOutput

func (ListingIamMemberConditionPtrOutput) Elem 

func (o ListingIamMemberConditionPtrOutput) Elem() ListingIamMemberConditionOutput

func (ListingIamMemberConditionPtrOutput) ElementType 

func (ListingIamMemberConditionPtrOutput) ElementType() reflect.Type

func (ListingIamMemberConditionPtrOutput) Expression 

func (o ListingIamMemberConditionPtrOutput) Expression() pulumi.StringPtrOutput

func (ListingIamMemberConditionPtrOutput) Title 

func (o ListingIamMemberConditionPtrOutput) Title() pulumi.StringPtrOutput

func (ListingIamMemberConditionPtrOutput) ToListingIamMemberConditionPtrOutput 

func (o ListingIamMemberConditionPtrOutput) ToListingIamMemberConditionPtrOutput() ListingIamMemberConditionPtrOutput

func (ListingIamMemberConditionPtrOutput) ToListingIamMemberConditionPtrOutputWithContext 

func (o ListingIamMemberConditionPtrOutput) ToListingIamMemberConditionPtrOutputWithContext(ctx context.Context) ListingIamMemberConditionPtrOutput

type ListingIamMemberInput 

type ListingIamMemberInput interface {
	pulumi.Input

	ToListingIamMemberOutput() ListingIamMemberOutput
	ToListingIamMemberOutputWithContext(ctx context.Context) ListingIamMemberOutput
}

type ListingIamMemberMap 

type ListingIamMemberMap map[string]ListingIamMemberInput

func (ListingIamMemberMap) ElementType 

func (ListingIamMemberMap) ElementType() reflect.Type

func (ListingIamMemberMap) ToListingIamMemberMapOutput 

func (i ListingIamMemberMap) ToListingIamMemberMapOutput() ListingIamMemberMapOutput

func (ListingIamMemberMap) ToListingIamMemberMapOutputWithContext 

func (i ListingIamMemberMap) ToListingIamMemberMapOutputWithContext(ctx context.Context) ListingIamMemberMapOutput

type ListingIamMemberMapInput 

type ListingIamMemberMapInput interface {
	pulumi.Input

	ToListingIamMemberMapOutput() ListingIamMemberMapOutput
	ToListingIamMemberMapOutputWithContext(context.Context) ListingIamMemberMapOutput
}

ListingIamMemberMapInput is an input type that accepts ListingIamMemberMap and ListingIamMemberMapOutput values. You can construct a concrete instance of `ListingIamMemberMapInput` via: 

ListingIamMemberMap{ "key": ListingIamMemberArgs{...} }

type ListingIamMemberMapOutput 

type ListingIamMemberMapOutput struct{ *pulumi.OutputState }

func (ListingIamMemberMapOutput) ElementType 

func (ListingIamMemberMapOutput) ElementType() reflect.Type

func (ListingIamMemberMapOutput) MapIndex 

func (o ListingIamMemberMapOutput) MapIndex(k pulumi.StringInput) ListingIamMemberOutput

func (ListingIamMemberMapOutput) ToListingIamMemberMapOutput 

func (o ListingIamMemberMapOutput) ToListingIamMemberMapOutput() ListingIamMemberMapOutput

func (ListingIamMemberMapOutput) ToListingIamMemberMapOutputWithContext 

func (o ListingIamMemberMapOutput) ToListingIamMemberMapOutputWithContext(ctx context.Context) ListingIamMemberMapOutput

type ListingIamMemberOutput 

type ListingIamMemberOutput struct{ *pulumi.OutputState }

func (ListingIamMemberOutput) Condition 

func (o ListingIamMemberOutput) Condition() ListingIamMemberConditionPtrOutput

func (ListingIamMemberOutput) DataExchangeId 

func (o ListingIamMemberOutput) DataExchangeId() pulumi.StringOutput

The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to

func (ListingIamMemberOutput) ElementType 

func (ListingIamMemberOutput) ElementType() reflect.Type

func (ListingIamMemberOutput) Etag 

func (o ListingIamMemberOutput) Etag() pulumi.StringOutput

(Computed) The etag of the IAM policy.

func (ListingIamMemberOutput) ListingId 

func (o ListingIamMemberOutput) ListingId() pulumi.StringOutput

The ID of the listing. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to

func (ListingIamMemberOutput) Location 

func (o ListingIamMemberOutput) Location() pulumi.StringOutput

The name of the location this data exchange listing. Used to find the parent resource to bind the IAM policy to

func (ListingIamMemberOutput) Member 

func (o ListingIamMemberOutput) Member() pulumi.StringOutput

Identities that will be granted the privilege in `role`. Each entry can have one of the following values: * **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account. * **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account. * **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com. * **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com. * **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com. * **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com. * **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project" * **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project" * **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"

func (ListingIamMemberOutput) Project 

func (o ListingIamMemberOutput) Project() pulumi.StringOutput

The ID of the project in which the resource belongs. If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.

func (ListingIamMemberOutput) Role 

func (o ListingIamMemberOutput) Role() pulumi.StringOutput

The role that should be applied. Only one `bigqueryanalyticshub.ListingIamBinding` can be used per role. Note that custom roles must be of the format `[projects|organizations]/{parent-name}/roles/{role-name}`.

func (ListingIamMemberOutput) ToListingIamMemberOutput 

func (o ListingIamMemberOutput) ToListingIamMemberOutput() ListingIamMemberOutput

func (ListingIamMemberOutput) ToListingIamMemberOutputWithContext 

func (o ListingIamMemberOutput) ToListingIamMemberOutputWithContext(ctx context.Context) ListingIamMemberOutput

type ListingIamMemberState 

type ListingIamMemberState struct {
	Condition ListingIamMemberConditionPtrInput
	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	DataExchangeId pulumi.StringPtrInput
	// (Computed) The etag of the IAM policy.
	Etag pulumi.StringPtrInput
	// The ID of the listing. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	ListingId pulumi.StringPtrInput
	// The name of the location this data exchange listing.
	// Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringPtrInput
	// Identities that will be granted the privilege in `role`.
	// Each entry can have one of the following values:
	// * **allUsers**: A special identifier that represents anyone who is on the internet; with or without a Google account.
	// * **allAuthenticatedUsers**: A special identifier that represents anyone who is authenticated with a Google account or a service account.
	// * **user:{emailid}**: An email address that represents a specific Google account. For example, alice@gmail.com or joe@example.com.
	// * **serviceAccount:{emailid}**: An email address that represents a service account. For example, my-other-app@appspot.gserviceaccount.com.
	// * **group:{emailid}**: An email address that represents a Google group. For example, admins@example.com.
	// * **domain:{domain}**: A G Suite domain (primary, instead of alias) name that represents all the users of that domain. For example, google.com or example.com.
	// * **projectOwner:projectid**: Owners of the given project. For example, "projectOwner:my-example-project"
	// * **projectEditor:projectid**: Editors of the given project. For example, "projectEditor:my-example-project"
	// * **projectViewer:projectid**: Viewers of the given project. For example, "projectViewer:my-example-project"
	Member pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
	// The role that should be applied. Only one
	// `bigqueryanalyticshub.ListingIamBinding` can be used per role. Note that custom roles must be of the format
	// `[projects|organizations]/{parent-name}/roles/{role-name}`.
	Role pulumi.StringPtrInput
}

func (ListingIamMemberState) ElementType 

func (ListingIamMemberState) ElementType() reflect.Type

type ListingIamPolicy 

type ListingIamPolicy struct {
	pulumi.CustomResourceState

	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	DataExchangeId pulumi.StringOutput `pulumi:"dataExchangeId"`
	// (Computed) The etag of the IAM policy.
	Etag pulumi.StringOutput `pulumi:"etag"`
	// The ID of the listing. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	ListingId pulumi.StringOutput `pulumi:"listingId"`
	// The name of the location this data exchange listing.
	// Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringOutput `pulumi:"location"`
	// The policy data generated by
	// a `organizations.getIAMPolicy` data source.
	PolicyData pulumi.StringOutput `pulumi:"policyData"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringOutput `pulumi:"project"`
}

Three different resources help you manage your IAM policy for Bigquery Analytics Hub Listing. Each of these resources serves a different use case:

* `bigqueryanalyticshub.ListingIamPolicy`: Authoritative. Sets the IAM policy for the listing and replaces any existing policy already attached. * `bigqueryanalyticshub.ListingIamBinding`: Authoritative for a given role. Updates the IAM policy to grant a role to a list of members. Other roles within the IAM policy for the listing are preserved. * `bigqueryanalyticshub.ListingIamMember`: Non-authoritative. Updates the IAM policy to grant a role to a new member. Other members for the role for the listing are preserved.

A data source can be used to retrieve policy data in advent you do not need creation

* `bigqueryanalyticshub.ListingIamPolicy`: Retrieves the IAM policy for the listing

> **Note:** `bigqueryanalyticshub.ListingIamPolicy` **cannot** be used in conjunction with `bigqueryanalyticshub.ListingIamBinding` and `bigqueryanalyticshub.ListingIamMember` or they will fight over what your policy should be.

> **Note:** `bigqueryanalyticshub.ListingIamBinding` resources **can be** used in conjunction with `bigqueryanalyticshub.ListingIamMember` resources **only if** they do not grant privilege to the same role.

## google\_bigquery\_analytics\_hub\_listing\_iam\_policy

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				{
					Role: "roles/viewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = bigqueryanalyticshub.NewListingIamPolicy(ctx, "policy", &bigqueryanalyticshub.ListingIamPolicyArgs{
			Project:        pulumi.Any(listing.Project),
			Location:       pulumi.Any(listing.Location),
			DataExchangeId: pulumi.Any(listing.DataExchangeId),
			ListingId:      pulumi.Any(listing.ListingId),
			PolicyData:     pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_listing\_iam\_binding

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.NewListingIamBinding(ctx, "binding", &bigqueryanalyticshub.ListingIamBindingArgs{
			Project:        pulumi.Any(listing.Project),
			Location:       pulumi.Any(listing.Location),
			DataExchangeId: pulumi.Any(listing.DataExchangeId),
			ListingId:      pulumi.Any(listing.ListingId),
			Role:           pulumi.String("roles/viewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_listing\_iam\_member

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.NewListingIamMember(ctx, "member", &bigqueryanalyticshub.ListingIamMemberArgs{
			Project:        pulumi.Any(listing.Project),
			Location:       pulumi.Any(listing.Location),
			DataExchangeId: pulumi.Any(listing.DataExchangeId),
			ListingId:      pulumi.Any(listing.ListingId),
			Role:           pulumi.String("roles/viewer"),
			Member:         pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_listing\_iam\_policy

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/organizations"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		admin, err := organizations.LookupIAMPolicy(ctx, &organizations.LookupIAMPolicyArgs{
			Bindings: []organizations.GetIAMPolicyBinding{
				{
					Role: "roles/viewer",
					Members: []string{
						"user:jane@example.com",
					},
				},
			},
		}, nil)
		if err != nil {
			return err
		}
		_, err = bigqueryanalyticshub.NewListingIamPolicy(ctx, "policy", &bigqueryanalyticshub.ListingIamPolicyArgs{
			Project:        pulumi.Any(listing.Project),
			Location:       pulumi.Any(listing.Location),
			DataExchangeId: pulumi.Any(listing.DataExchangeId),
			ListingId:      pulumi.Any(listing.ListingId),
			PolicyData:     pulumi.String(admin.PolicyData),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_listing\_iam\_binding

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.NewListingIamBinding(ctx, "binding", &bigqueryanalyticshub.ListingIamBindingArgs{
			Project:        pulumi.Any(listing.Project),
			Location:       pulumi.Any(listing.Location),
			DataExchangeId: pulumi.Any(listing.DataExchangeId),
			ListingId:      pulumi.Any(listing.ListingId),
			Role:           pulumi.String("roles/viewer"),
			Members: pulumi.StringArray{
				pulumi.String("user:jane@example.com"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## google\_bigquery\_analytics\_hub\_listing\_iam\_member

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.NewListingIamMember(ctx, "member", &bigqueryanalyticshub.ListingIamMemberArgs{
			Project:        pulumi.Any(listing.Project),
			Location:       pulumi.Any(listing.Location),
			DataExchangeId: pulumi.Any(listing.DataExchangeId),
			ListingId:      pulumi.Any(listing.ListingId),
			Role:           pulumi.String("roles/viewer"),
			Member:         pulumi.String("user:jane@example.com"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

```

## Import

For all import syntaxes, the "resource in question" can take any of the following forms:

* projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}}/listings/{{listing_id}}

* {{project}}/{{location}}/{{data_exchange_id}}/{{listing_id}}

* {{location}}/{{data_exchange_id}}/{{listing_id}}

* {{listing_id}}

Any variables not passed in the import command will be taken from the provider configuration.

Bigquery Analytics Hub listing IAM resources can be imported using the resource identifiers, role, and member.

IAM member imports use space-delimited identifiers: the resource in question, the role, and the member identity, e.g.

```sh $ pulumi import gcp:bigqueryanalyticshub/listingIamPolicy:ListingIamPolicy editor "projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}}/listings/{{listing_id}} roles/viewer user:jane@example.com" ```

IAM binding imports use space-delimited identifiers: the resource in question and the role, e.g.

```sh $ pulumi import gcp:bigqueryanalyticshub/listingIamPolicy:ListingIamPolicy editor "projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}}/listings/{{listing_id}} roles/viewer" ```

IAM policy imports use the identifier of the resource in question, e.g.

```sh $ pulumi import gcp:bigqueryanalyticshub/listingIamPolicy:ListingIamPolicy editor projects/{{project}}/locations/{{location}}/dataExchanges/{{data_exchange_id}}/listings/{{listing_id}} ```

-> **Custom Roles**: If you're importing a IAM resource with a custom role, make sure to use the 

full name of the custom role, e.g. `[projects/my-project|organizations/my-org]/roles/my-custom-role`.

func GetListingIamPolicy 

func GetListingIamPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ListingIamPolicyState, opts ...pulumi.ResourceOption) (*ListingIamPolicy, error)

GetListingIamPolicy gets an existing ListingIamPolicy resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

func NewListingIamPolicy 

func NewListingIamPolicy(ctx *pulumi.Context,
	name string, args *ListingIamPolicyArgs, opts ...pulumi.ResourceOption) (*ListingIamPolicy, error)

NewListingIamPolicy registers a new resource with the given unique name, arguments, and options.

func (*ListingIamPolicy) ElementType 

func (*ListingIamPolicy) ElementType() reflect.Type

func (*ListingIamPolicy) ToListingIamPolicyOutput 

func (i *ListingIamPolicy) ToListingIamPolicyOutput() ListingIamPolicyOutput

func (*ListingIamPolicy) ToListingIamPolicyOutputWithContext 

func (i *ListingIamPolicy) ToListingIamPolicyOutputWithContext(ctx context.Context) ListingIamPolicyOutput

type ListingIamPolicyArgs 

type ListingIamPolicyArgs struct {
	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	DataExchangeId pulumi.StringInput
	// The ID of the listing. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	ListingId pulumi.StringInput
	// The name of the location this data exchange listing.
	// Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringPtrInput
	// The policy data generated by
	// a `organizations.getIAMPolicy` data source.
	PolicyData pulumi.StringInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
}

The set of arguments for constructing a ListingIamPolicy resource.

func (ListingIamPolicyArgs) ElementType 

func (ListingIamPolicyArgs) ElementType() reflect.Type

type ListingIamPolicyArray 

type ListingIamPolicyArray []ListingIamPolicyInput

func (ListingIamPolicyArray) ElementType 

func (ListingIamPolicyArray) ElementType() reflect.Type

func (ListingIamPolicyArray) ToListingIamPolicyArrayOutput 

func (i ListingIamPolicyArray) ToListingIamPolicyArrayOutput() ListingIamPolicyArrayOutput

func (ListingIamPolicyArray) ToListingIamPolicyArrayOutputWithContext 

func (i ListingIamPolicyArray) ToListingIamPolicyArrayOutputWithContext(ctx context.Context) ListingIamPolicyArrayOutput

type ListingIamPolicyArrayInput 

type ListingIamPolicyArrayInput interface {
	pulumi.Input

	ToListingIamPolicyArrayOutput() ListingIamPolicyArrayOutput
	ToListingIamPolicyArrayOutputWithContext(context.Context) ListingIamPolicyArrayOutput
}

ListingIamPolicyArrayInput is an input type that accepts ListingIamPolicyArray and ListingIamPolicyArrayOutput values. You can construct a concrete instance of `ListingIamPolicyArrayInput` via: 

ListingIamPolicyArray{ ListingIamPolicyArgs{...} }

type ListingIamPolicyArrayOutput 

type ListingIamPolicyArrayOutput struct{ *pulumi.OutputState }

func (ListingIamPolicyArrayOutput) ElementType 

func (ListingIamPolicyArrayOutput) ElementType() reflect.Type

func (ListingIamPolicyArrayOutput) Index 

func (o ListingIamPolicyArrayOutput) Index(i pulumi.IntInput) ListingIamPolicyOutput

func (ListingIamPolicyArrayOutput) ToListingIamPolicyArrayOutput 

func (o ListingIamPolicyArrayOutput) ToListingIamPolicyArrayOutput() ListingIamPolicyArrayOutput

func (ListingIamPolicyArrayOutput) ToListingIamPolicyArrayOutputWithContext 

func (o ListingIamPolicyArrayOutput) ToListingIamPolicyArrayOutputWithContext(ctx context.Context) ListingIamPolicyArrayOutput

type ListingIamPolicyInput 

type ListingIamPolicyInput interface {
	pulumi.Input

	ToListingIamPolicyOutput() ListingIamPolicyOutput
	ToListingIamPolicyOutputWithContext(ctx context.Context) ListingIamPolicyOutput
}

type ListingIamPolicyMap 

type ListingIamPolicyMap map[string]ListingIamPolicyInput

func (ListingIamPolicyMap) ElementType 

func (ListingIamPolicyMap) ElementType() reflect.Type

func (ListingIamPolicyMap) ToListingIamPolicyMapOutput 

func (i ListingIamPolicyMap) ToListingIamPolicyMapOutput() ListingIamPolicyMapOutput

func (ListingIamPolicyMap) ToListingIamPolicyMapOutputWithContext 

func (i ListingIamPolicyMap) ToListingIamPolicyMapOutputWithContext(ctx context.Context) ListingIamPolicyMapOutput

type ListingIamPolicyMapInput 

type ListingIamPolicyMapInput interface {
	pulumi.Input

	ToListingIamPolicyMapOutput() ListingIamPolicyMapOutput
	ToListingIamPolicyMapOutputWithContext(context.Context) ListingIamPolicyMapOutput
}

ListingIamPolicyMapInput is an input type that accepts ListingIamPolicyMap and ListingIamPolicyMapOutput values. You can construct a concrete instance of `ListingIamPolicyMapInput` via: 

ListingIamPolicyMap{ "key": ListingIamPolicyArgs{...} }

type ListingIamPolicyMapOutput 

type ListingIamPolicyMapOutput struct{ *pulumi.OutputState }

func (ListingIamPolicyMapOutput) ElementType 

func (ListingIamPolicyMapOutput) ElementType() reflect.Type

func (ListingIamPolicyMapOutput) MapIndex 

func (o ListingIamPolicyMapOutput) MapIndex(k pulumi.StringInput) ListingIamPolicyOutput

func (ListingIamPolicyMapOutput) ToListingIamPolicyMapOutput 

func (o ListingIamPolicyMapOutput) ToListingIamPolicyMapOutput() ListingIamPolicyMapOutput

func (ListingIamPolicyMapOutput) ToListingIamPolicyMapOutputWithContext 

func (o ListingIamPolicyMapOutput) ToListingIamPolicyMapOutputWithContext(ctx context.Context) ListingIamPolicyMapOutput

type ListingIamPolicyOutput 

type ListingIamPolicyOutput struct{ *pulumi.OutputState }

func (ListingIamPolicyOutput) DataExchangeId 

func (o ListingIamPolicyOutput) DataExchangeId() pulumi.StringOutput

The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to

func (ListingIamPolicyOutput) ElementType 

func (ListingIamPolicyOutput) ElementType() reflect.Type

func (ListingIamPolicyOutput) Etag 

func (o ListingIamPolicyOutput) Etag() pulumi.StringOutput

(Computed) The etag of the IAM policy.

func (ListingIamPolicyOutput) ListingId 

func (o ListingIamPolicyOutput) ListingId() pulumi.StringOutput

The ID of the listing. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to

func (ListingIamPolicyOutput) Location 

func (o ListingIamPolicyOutput) Location() pulumi.StringOutput

The name of the location this data exchange listing. Used to find the parent resource to bind the IAM policy to

func (ListingIamPolicyOutput) PolicyData 

func (o ListingIamPolicyOutput) PolicyData() pulumi.StringOutput

The policy data generated by a `organizations.getIAMPolicy` data source.

func (ListingIamPolicyOutput) Project 

func (o ListingIamPolicyOutput) Project() pulumi.StringOutput

The ID of the project in which the resource belongs. If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.

func (ListingIamPolicyOutput) ToListingIamPolicyOutput 

func (o ListingIamPolicyOutput) ToListingIamPolicyOutput() ListingIamPolicyOutput

func (ListingIamPolicyOutput) ToListingIamPolicyOutputWithContext 

func (o ListingIamPolicyOutput) ToListingIamPolicyOutputWithContext(ctx context.Context) ListingIamPolicyOutput

type ListingIamPolicyState 

type ListingIamPolicyState struct {
	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	DataExchangeId pulumi.StringPtrInput
	// (Computed) The etag of the IAM policy.
	Etag pulumi.StringPtrInput
	// The ID of the listing. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	ListingId pulumi.StringPtrInput
	// The name of the location this data exchange listing.
	// Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringPtrInput
	// The policy data generated by
	// a `organizations.getIAMPolicy` data source.
	PolicyData pulumi.StringPtrInput
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput
}

func (ListingIamPolicyState) ElementType 

func (ListingIamPolicyState) ElementType() reflect.Type

type ListingInput 

type ListingInput interface {
	pulumi.Input

	ToListingOutput() ListingOutput
	ToListingOutputWithContext(ctx context.Context) ListingOutput
}

type ListingMap 

type ListingMap map[string]ListingInput

func (ListingMap) ElementType 

func (ListingMap) ElementType() reflect.Type

func (ListingMap) ToListingMapOutput 

func (i ListingMap) ToListingMapOutput() ListingMapOutput

func (ListingMap) ToListingMapOutputWithContext 

func (i ListingMap) ToListingMapOutputWithContext(ctx context.Context) ListingMapOutput

type ListingMapInput 

type ListingMapInput interface {
	pulumi.Input

	ToListingMapOutput() ListingMapOutput
	ToListingMapOutputWithContext(context.Context) ListingMapOutput
}

ListingMapInput is an input type that accepts ListingMap and ListingMapOutput values. You can construct a concrete instance of `ListingMapInput` via: 

ListingMap{ "key": ListingArgs{...} }

type ListingMapOutput 

type ListingMapOutput struct{ *pulumi.OutputState }

func (ListingMapOutput) ElementType 

func (ListingMapOutput) ElementType() reflect.Type

func (ListingMapOutput) MapIndex 

func (o ListingMapOutput) MapIndex(k pulumi.StringInput) ListingOutput

func (ListingMapOutput) ToListingMapOutput 

func (o ListingMapOutput) ToListingMapOutput() ListingMapOutput

func (ListingMapOutput) ToListingMapOutputWithContext 

func (o ListingMapOutput) ToListingMapOutputWithContext(ctx context.Context) ListingMapOutput

type ListingOutput 

type ListingOutput struct{ *pulumi.OutputState }

func (ListingOutput) BigqueryDataset 

func (o ListingOutput) BigqueryDataset() ListingBigqueryDatasetOutput

Shared dataset i.e. BigQuery dataset source. Structure is documented below.

func (ListingOutput) Categories 

func (o ListingOutput) Categories() pulumi.StringArrayOutput

Categories of the listing. Up to two categories are allowed.

func (ListingOutput) DataExchangeId 

func (o ListingOutput) DataExchangeId() pulumi.StringOutput

The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces.

func (ListingOutput) DataProvider 

func (o ListingOutput) DataProvider() ListingDataProviderPtrOutput

Details of the data provider who owns the source data.

func (ListingOutput) Description 

func (o ListingOutput) Description() pulumi.StringPtrOutput

Short description of the listing. The description must not contain Unicode non-characters and C0 and C1 control codes except tabs (HT), new lines (LF), carriage returns (CR), and page breaks (FF).

func (ListingOutput) DisplayName 

func (o ListingOutput) DisplayName() pulumi.StringOutput

Human-readable display name of the listing. The display name must contain only Unicode letters, numbers (0-9), underscores (_), dashes (-), spaces ( ), ampersands (&) and can't start or end with spaces.

func (ListingOutput) Documentation 

func (o ListingOutput) Documentation() pulumi.StringPtrOutput

Documentation describing the listing.

func (ListingOutput) ElementType 

func (ListingOutput) ElementType() reflect.Type

func (ListingOutput) Icon 

func (o ListingOutput) Icon() pulumi.StringPtrOutput

Base64 encoded image representing the listing.

func (ListingOutput) ListingId 

func (o ListingOutput) ListingId() pulumi.StringOutput

The ID of the listing. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces.

func (ListingOutput) Location 

func (o ListingOutput) Location() pulumi.StringOutput

The name of the location this data exchange listing.

func (ListingOutput) Name 

func (o ListingOutput) Name() pulumi.StringOutput

The resource name of the listing. e.g. "projects/myproject/locations/US/dataExchanges/123/listings/456"

func (ListingOutput) PrimaryContact 

func (o ListingOutput) PrimaryContact() pulumi.StringPtrOutput

Email or URL of the primary point of contact of the listing.

func (ListingOutput) Project 

func (o ListingOutput) Project() pulumi.StringOutput

func (ListingOutput) Publisher 

func (o ListingOutput) Publisher() ListingPublisherPtrOutput

Details of the publisher who owns the listing and who can share the source data.

func (ListingOutput) RequestAccess 

func (o ListingOutput) RequestAccess() pulumi.StringPtrOutput

Email or URL of the request access of the listing. Subscribers can use this reference to request access.

func (ListingOutput) RestrictedExportConfig added in v7.5.0 

func (o ListingOutput) RestrictedExportConfig() ListingRestrictedExportConfigPtrOutput

If set, restricted export configuration will be propagated and enforced on the linked dataset.

func (ListingOutput) ToListingOutput 

func (o ListingOutput) ToListingOutput() ListingOutput

func (ListingOutput) ToListingOutputWithContext 

func (o ListingOutput) ToListingOutputWithContext(ctx context.Context) ListingOutput

type ListingPublisher 

type ListingPublisher struct {
	// Name of the listing publisher.
	Name string `pulumi:"name"`
	// Email or URL of the listing publisher.
	PrimaryContact *string `pulumi:"primaryContact"`
}

type ListingPublisherArgs 

type ListingPublisherArgs struct {
	// Name of the listing publisher.
	Name pulumi.StringInput `pulumi:"name"`
	// Email or URL of the listing publisher.
	PrimaryContact pulumi.StringPtrInput `pulumi:"primaryContact"`
}

func (ListingPublisherArgs) ElementType 

func (ListingPublisherArgs) ElementType() reflect.Type

func (ListingPublisherArgs) ToListingPublisherOutput 

func (i ListingPublisherArgs) ToListingPublisherOutput() ListingPublisherOutput

func (ListingPublisherArgs) ToListingPublisherOutputWithContext 

func (i ListingPublisherArgs) ToListingPublisherOutputWithContext(ctx context.Context) ListingPublisherOutput

func (ListingPublisherArgs) ToListingPublisherPtrOutput 

func (i ListingPublisherArgs) ToListingPublisherPtrOutput() ListingPublisherPtrOutput

func (ListingPublisherArgs) ToListingPublisherPtrOutputWithContext 

func (i ListingPublisherArgs) ToListingPublisherPtrOutputWithContext(ctx context.Context) ListingPublisherPtrOutput

type ListingPublisherInput 

type ListingPublisherInput interface {
	pulumi.Input

	ToListingPublisherOutput() ListingPublisherOutput
	ToListingPublisherOutputWithContext(context.Context) ListingPublisherOutput
}

ListingPublisherInput is an input type that accepts ListingPublisherArgs and ListingPublisherOutput values. You can construct a concrete instance of `ListingPublisherInput` via: 

ListingPublisherArgs{...}

type ListingPublisherOutput 

type ListingPublisherOutput struct{ *pulumi.OutputState }

func (ListingPublisherOutput) ElementType 

func (ListingPublisherOutput) ElementType() reflect.Type

func (ListingPublisherOutput) Name 

func (o ListingPublisherOutput) Name() pulumi.StringOutput

Name of the listing publisher.

func (ListingPublisherOutput) PrimaryContact 

func (o ListingPublisherOutput) PrimaryContact() pulumi.StringPtrOutput

Email or URL of the listing publisher.

func (ListingPublisherOutput) ToListingPublisherOutput 

func (o ListingPublisherOutput) ToListingPublisherOutput() ListingPublisherOutput

func (ListingPublisherOutput) ToListingPublisherOutputWithContext 

func (o ListingPublisherOutput) ToListingPublisherOutputWithContext(ctx context.Context) ListingPublisherOutput

func (ListingPublisherOutput) ToListingPublisherPtrOutput 

func (o ListingPublisherOutput) ToListingPublisherPtrOutput() ListingPublisherPtrOutput

func (ListingPublisherOutput) ToListingPublisherPtrOutputWithContext 

func (o ListingPublisherOutput) ToListingPublisherPtrOutputWithContext(ctx context.Context) ListingPublisherPtrOutput

type ListingPublisherPtrInput 

type ListingPublisherPtrInput interface {
	pulumi.Input

	ToListingPublisherPtrOutput() ListingPublisherPtrOutput
	ToListingPublisherPtrOutputWithContext(context.Context) ListingPublisherPtrOutput
}

ListingPublisherPtrInput is an input type that accepts ListingPublisherArgs, ListingPublisherPtr and ListingPublisherPtrOutput values. You can construct a concrete instance of `ListingPublisherPtrInput` via: 

        ListingPublisherArgs{...}

or:

        nil

func ListingPublisherPtr 

func ListingPublisherPtr(v *ListingPublisherArgs) ListingPublisherPtrInput

type ListingPublisherPtrOutput 

type ListingPublisherPtrOutput struct{ *pulumi.OutputState }

func (ListingPublisherPtrOutput) Elem 

func (o ListingPublisherPtrOutput) Elem() ListingPublisherOutput

func (ListingPublisherPtrOutput) ElementType 

func (ListingPublisherPtrOutput) ElementType() reflect.Type

func (ListingPublisherPtrOutput) Name 

func (o ListingPublisherPtrOutput) Name() pulumi.StringPtrOutput

Name of the listing publisher.

func (ListingPublisherPtrOutput) PrimaryContact 

func (o ListingPublisherPtrOutput) PrimaryContact() pulumi.StringPtrOutput

Email or URL of the listing publisher.

func (ListingPublisherPtrOutput) ToListingPublisherPtrOutput 

func (o ListingPublisherPtrOutput) ToListingPublisherPtrOutput() ListingPublisherPtrOutput

func (ListingPublisherPtrOutput) ToListingPublisherPtrOutputWithContext 

func (o ListingPublisherPtrOutput) ToListingPublisherPtrOutputWithContext(ctx context.Context) ListingPublisherPtrOutput

type ListingRestrictedExportConfig added in v7.5.0 

type ListingRestrictedExportConfig struct {
	// If true, enable restricted export.
	Enabled *bool `pulumi:"enabled"`
	// If true, restrict export of query result derived from restricted linked dataset table.
	RestrictQueryResult *bool `pulumi:"restrictQueryResult"`
}

type ListingRestrictedExportConfigArgs added in v7.5.0 

type ListingRestrictedExportConfigArgs struct {
	// If true, enable restricted export.
	Enabled pulumi.BoolPtrInput `pulumi:"enabled"`
	// If true, restrict export of query result derived from restricted linked dataset table.
	RestrictQueryResult pulumi.BoolPtrInput `pulumi:"restrictQueryResult"`
}

func (ListingRestrictedExportConfigArgs) ElementType added in v7.5.0 

func (ListingRestrictedExportConfigArgs) ElementType() reflect.Type

func (ListingRestrictedExportConfigArgs) ToListingRestrictedExportConfigOutput added in v7.5.0 

func (i ListingRestrictedExportConfigArgs) ToListingRestrictedExportConfigOutput() ListingRestrictedExportConfigOutput

func (ListingRestrictedExportConfigArgs) ToListingRestrictedExportConfigOutputWithContext added in v7.5.0 

func (i ListingRestrictedExportConfigArgs) ToListingRestrictedExportConfigOutputWithContext(ctx context.Context) ListingRestrictedExportConfigOutput

func (ListingRestrictedExportConfigArgs) ToListingRestrictedExportConfigPtrOutput added in v7.5.0 

func (i ListingRestrictedExportConfigArgs) ToListingRestrictedExportConfigPtrOutput() ListingRestrictedExportConfigPtrOutput

func (ListingRestrictedExportConfigArgs) ToListingRestrictedExportConfigPtrOutputWithContext added in v7.5.0 

func (i ListingRestrictedExportConfigArgs) ToListingRestrictedExportConfigPtrOutputWithContext(ctx context.Context) ListingRestrictedExportConfigPtrOutput

type ListingRestrictedExportConfigInput added in v7.5.0 

type ListingRestrictedExportConfigInput interface {
	pulumi.Input

	ToListingRestrictedExportConfigOutput() ListingRestrictedExportConfigOutput
	ToListingRestrictedExportConfigOutputWithContext(context.Context) ListingRestrictedExportConfigOutput
}

ListingRestrictedExportConfigInput is an input type that accepts ListingRestrictedExportConfigArgs and ListingRestrictedExportConfigOutput values. You can construct a concrete instance of `ListingRestrictedExportConfigInput` via: 

ListingRestrictedExportConfigArgs{...}

type ListingRestrictedExportConfigOutput added in v7.5.0 

type ListingRestrictedExportConfigOutput struct{ *pulumi.OutputState }

func (ListingRestrictedExportConfigOutput) ElementType added in v7.5.0 

func (ListingRestrictedExportConfigOutput) ElementType() reflect.Type

func (ListingRestrictedExportConfigOutput) Enabled added in v7.5.0 

func (o ListingRestrictedExportConfigOutput) Enabled() pulumi.BoolPtrOutput

If true, enable restricted export.

func (ListingRestrictedExportConfigOutput) RestrictQueryResult added in v7.5.0 

func (o ListingRestrictedExportConfigOutput) RestrictQueryResult() pulumi.BoolPtrOutput

If true, restrict export of query result derived from restricted linked dataset table.

func (ListingRestrictedExportConfigOutput) ToListingRestrictedExportConfigOutput added in v7.5.0 

func (o ListingRestrictedExportConfigOutput) ToListingRestrictedExportConfigOutput() ListingRestrictedExportConfigOutput

func (ListingRestrictedExportConfigOutput) ToListingRestrictedExportConfigOutputWithContext added in v7.5.0 

func (o ListingRestrictedExportConfigOutput) ToListingRestrictedExportConfigOutputWithContext(ctx context.Context) ListingRestrictedExportConfigOutput

func (ListingRestrictedExportConfigOutput) ToListingRestrictedExportConfigPtrOutput added in v7.5.0 

func (o ListingRestrictedExportConfigOutput) ToListingRestrictedExportConfigPtrOutput() ListingRestrictedExportConfigPtrOutput

func (ListingRestrictedExportConfigOutput) ToListingRestrictedExportConfigPtrOutputWithContext added in v7.5.0 

func (o ListingRestrictedExportConfigOutput) ToListingRestrictedExportConfigPtrOutputWithContext(ctx context.Context) ListingRestrictedExportConfigPtrOutput

type ListingRestrictedExportConfigPtrInput added in v7.5.0 

type ListingRestrictedExportConfigPtrInput interface {
	pulumi.Input

	ToListingRestrictedExportConfigPtrOutput() ListingRestrictedExportConfigPtrOutput
	ToListingRestrictedExportConfigPtrOutputWithContext(context.Context) ListingRestrictedExportConfigPtrOutput
}

ListingRestrictedExportConfigPtrInput is an input type that accepts ListingRestrictedExportConfigArgs, ListingRestrictedExportConfigPtr and ListingRestrictedExportConfigPtrOutput values. You can construct a concrete instance of `ListingRestrictedExportConfigPtrInput` via: 

        ListingRestrictedExportConfigArgs{...}

or:

        nil

func ListingRestrictedExportConfigPtr added in v7.5.0 

func ListingRestrictedExportConfigPtr(v *ListingRestrictedExportConfigArgs) ListingRestrictedExportConfigPtrInput

type ListingRestrictedExportConfigPtrOutput added in v7.5.0 

type ListingRestrictedExportConfigPtrOutput struct{ *pulumi.OutputState }

func (ListingRestrictedExportConfigPtrOutput) Elem added in v7.5.0 

func (o ListingRestrictedExportConfigPtrOutput) Elem() ListingRestrictedExportConfigOutput

func (ListingRestrictedExportConfigPtrOutput) ElementType added in v7.5.0 

func (ListingRestrictedExportConfigPtrOutput) ElementType() reflect.Type

func (ListingRestrictedExportConfigPtrOutput) Enabled added in v7.5.0 

func (o ListingRestrictedExportConfigPtrOutput) Enabled() pulumi.BoolPtrOutput

If true, enable restricted export.

func (ListingRestrictedExportConfigPtrOutput) RestrictQueryResult added in v7.5.0 

func (o ListingRestrictedExportConfigPtrOutput) RestrictQueryResult() pulumi.BoolPtrOutput

If true, restrict export of query result derived from restricted linked dataset table.

func (ListingRestrictedExportConfigPtrOutput) ToListingRestrictedExportConfigPtrOutput added in v7.5.0 

func (o ListingRestrictedExportConfigPtrOutput) ToListingRestrictedExportConfigPtrOutput() ListingRestrictedExportConfigPtrOutput

func (ListingRestrictedExportConfigPtrOutput) ToListingRestrictedExportConfigPtrOutputWithContext added in v7.5.0 

func (o ListingRestrictedExportConfigPtrOutput) ToListingRestrictedExportConfigPtrOutputWithContext(ctx context.Context) ListingRestrictedExportConfigPtrOutput

type ListingState 

type ListingState struct {
	// Shared dataset i.e. BigQuery dataset source.
	// Structure is documented below.
	BigqueryDataset ListingBigqueryDatasetPtrInput
	// Categories of the listing. Up to two categories are allowed.
	Categories pulumi.StringArrayInput
	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces.
	DataExchangeId pulumi.StringPtrInput
	// Details of the data provider who owns the source data.
	DataProvider ListingDataProviderPtrInput
	// Short description of the listing. The description must not contain Unicode non-characters and C0 and C1 control codes
	// except tabs (HT), new lines (LF), carriage returns (CR), and page breaks (FF).
	Description pulumi.StringPtrInput
	// Human-readable display name of the listing. The display name must contain only Unicode letters, numbers (0-9), underscores (_), dashes (-), spaces ( ), ampersands (&) and can't start or end with spaces.
	DisplayName pulumi.StringPtrInput
	// Documentation describing the listing.
	Documentation pulumi.StringPtrInput
	// Base64 encoded image representing the listing.
	Icon pulumi.StringPtrInput
	// The ID of the listing. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces.
	ListingId pulumi.StringPtrInput
	// The name of the location this data exchange listing.
	Location pulumi.StringPtrInput
	// The resource name of the listing. e.g. "projects/myproject/locations/US/dataExchanges/123/listings/456"
	Name pulumi.StringPtrInput
	// Email or URL of the primary point of contact of the listing.
	PrimaryContact pulumi.StringPtrInput
	Project        pulumi.StringPtrInput
	// Details of the publisher who owns the listing and who can share the source data.
	Publisher ListingPublisherPtrInput
	// Email or URL of the request access of the listing. Subscribers can use this reference to request access.
	RequestAccess pulumi.StringPtrInput
	// If set, restricted export configuration will be propagated and enforced on the linked dataset.
	RestrictedExportConfig ListingRestrictedExportConfigPtrInput
}

func (ListingState) ElementType 

func (ListingState) ElementType() reflect.Type

type LookupDataExchangeIamPolicyArgs 

type LookupDataExchangeIamPolicyArgs struct {
	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	DataExchangeId string `pulumi:"dataExchangeId"`
	// The name of the location this data exchange.
	// Used to find the parent resource to bind the IAM policy to
	Location *string `pulumi:"location"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project *string `pulumi:"project"`
}

A collection of arguments for invoking getDataExchangeIamPolicy.

type LookupDataExchangeIamPolicyOutputArgs 

type LookupDataExchangeIamPolicyOutputArgs struct {
	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	DataExchangeId pulumi.StringInput `pulumi:"dataExchangeId"`
	// The name of the location this data exchange.
	// Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringPtrInput `pulumi:"location"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput `pulumi:"project"`
}

A collection of arguments for invoking getDataExchangeIamPolicy.

func (LookupDataExchangeIamPolicyOutputArgs) ElementType 

func (LookupDataExchangeIamPolicyOutputArgs) ElementType() reflect.Type

type LookupDataExchangeIamPolicyResult 

type LookupDataExchangeIamPolicyResult struct {
	DataExchangeId string `pulumi:"dataExchangeId"`
	// (Computed) The etag of the IAM policy.
	Etag string `pulumi:"etag"`
	// The provider-assigned unique ID for this managed resource.
	Id       string `pulumi:"id"`
	Location string `pulumi:"location"`
	// (Required only by `bigqueryanalyticshub.DataExchangeIamPolicy`) The policy data generated by
	// a `organizations.getIAMPolicy` data source.
	PolicyData string `pulumi:"policyData"`
	Project    string `pulumi:"project"`
}

A collection of values returned by getDataExchangeIamPolicy.

func LookupDataExchangeIamPolicy 

func LookupDataExchangeIamPolicy(ctx *pulumi.Context, args *LookupDataExchangeIamPolicyArgs, opts ...pulumi.InvokeOption) (*LookupDataExchangeIamPolicyResult, error)

Retrieves the current IAM policy data for dataexchange

## example

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.LookupDataExchangeIamPolicy(ctx, &bigqueryanalyticshub.LookupDataExchangeIamPolicyArgs{
			Project:        pulumi.StringRef(dataExchange.Project),
			Location:       pulumi.StringRef(dataExchange.Location),
			DataExchangeId: dataExchange.DataExchangeId,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupDataExchangeIamPolicyResultOutput 

type LookupDataExchangeIamPolicyResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getDataExchangeIamPolicy.

func LookupDataExchangeIamPolicyOutput 

func LookupDataExchangeIamPolicyOutput(ctx *pulumi.Context, args LookupDataExchangeIamPolicyOutputArgs, opts ...pulumi.InvokeOption) LookupDataExchangeIamPolicyResultOutput

func (LookupDataExchangeIamPolicyResultOutput) DataExchangeId 

func (o LookupDataExchangeIamPolicyResultOutput) DataExchangeId() pulumi.StringOutput

func (LookupDataExchangeIamPolicyResultOutput) ElementType 

func (LookupDataExchangeIamPolicyResultOutput) ElementType() reflect.Type

func (LookupDataExchangeIamPolicyResultOutput) Etag 

func (o LookupDataExchangeIamPolicyResultOutput) Etag() pulumi.StringOutput

(Computed) The etag of the IAM policy.

func (LookupDataExchangeIamPolicyResultOutput) Id 

func (o LookupDataExchangeIamPolicyResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (LookupDataExchangeIamPolicyResultOutput) Location 

func (o LookupDataExchangeIamPolicyResultOutput) Location() pulumi.StringOutput

func (LookupDataExchangeIamPolicyResultOutput) PolicyData 

func (o LookupDataExchangeIamPolicyResultOutput) PolicyData() pulumi.StringOutput

(Required only by `bigqueryanalyticshub.DataExchangeIamPolicy`) The policy data generated by a `organizations.getIAMPolicy` data source.

func (LookupDataExchangeIamPolicyResultOutput) Project 

func (o LookupDataExchangeIamPolicyResultOutput) Project() pulumi.StringOutput

func (LookupDataExchangeIamPolicyResultOutput) ToLookupDataExchangeIamPolicyResultOutput 

func (o LookupDataExchangeIamPolicyResultOutput) ToLookupDataExchangeIamPolicyResultOutput() LookupDataExchangeIamPolicyResultOutput

func (LookupDataExchangeIamPolicyResultOutput) ToLookupDataExchangeIamPolicyResultOutputWithContext 

func (o LookupDataExchangeIamPolicyResultOutput) ToLookupDataExchangeIamPolicyResultOutputWithContext(ctx context.Context) LookupDataExchangeIamPolicyResultOutput

type LookupListingIamPolicyArgs 

type LookupListingIamPolicyArgs struct {
	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	DataExchangeId string `pulumi:"dataExchangeId"`
	// The ID of the listing. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	ListingId string `pulumi:"listingId"`
	// The name of the location this data exchange listing.
	// Used to find the parent resource to bind the IAM policy to
	Location *string `pulumi:"location"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project *string `pulumi:"project"`
}

A collection of arguments for invoking getListingIamPolicy.

type LookupListingIamPolicyOutputArgs 

type LookupListingIamPolicyOutputArgs struct {
	// The ID of the data exchange. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	DataExchangeId pulumi.StringInput `pulumi:"dataExchangeId"`
	// The ID of the listing. Must contain only Unicode letters, numbers (0-9), underscores (_). Should not use characters that require URL-escaping, or characters outside of ASCII, spaces. Used to find the parent resource to bind the IAM policy to
	ListingId pulumi.StringInput `pulumi:"listingId"`
	// The name of the location this data exchange listing.
	// Used to find the parent resource to bind the IAM policy to
	Location pulumi.StringPtrInput `pulumi:"location"`
	// The ID of the project in which the resource belongs.
	// If it is not provided, the project will be parsed from the identifier of the parent resource. If no project is provided in the parent identifier and no project is specified, the provider project is used.
	Project pulumi.StringPtrInput `pulumi:"project"`
}

A collection of arguments for invoking getListingIamPolicy.

func (LookupListingIamPolicyOutputArgs) ElementType 

func (LookupListingIamPolicyOutputArgs) ElementType() reflect.Type

type LookupListingIamPolicyResult 

type LookupListingIamPolicyResult struct {
	DataExchangeId string `pulumi:"dataExchangeId"`
	// (Computed) The etag of the IAM policy.
	Etag string `pulumi:"etag"`
	// The provider-assigned unique ID for this managed resource.
	Id        string `pulumi:"id"`
	ListingId string `pulumi:"listingId"`
	Location  string `pulumi:"location"`
	// (Required only by `bigqueryanalyticshub.ListingIamPolicy`) The policy data generated by
	// a `organizations.getIAMPolicy` data source.
	PolicyData string `pulumi:"policyData"`
	Project    string `pulumi:"project"`
}

A collection of values returned by getListingIamPolicy.

func LookupListingIamPolicy 

func LookupListingIamPolicy(ctx *pulumi.Context, args *LookupListingIamPolicyArgs, opts ...pulumi.InvokeOption) (*LookupListingIamPolicyResult, error)

Retrieves the current IAM policy data for listing

## example

```go package main

import ( 

"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/bigqueryanalyticshub"
"github.com/pulumi/pulumi/sdk/v3/go/pulumi"

) 

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := bigqueryanalyticshub.LookupListingIamPolicy(ctx, &bigqueryanalyticshub.LookupListingIamPolicyArgs{
			Project:        pulumi.StringRef(listing.Project),
			Location:       pulumi.StringRef(listing.Location),
			DataExchangeId: listing.DataExchangeId,
			ListingId:      listing.ListingId,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

```

type LookupListingIamPolicyResultOutput 

type LookupListingIamPolicyResultOutput struct{ *pulumi.OutputState }

A collection of values returned by getListingIamPolicy.

func LookupListingIamPolicyOutput 

func LookupListingIamPolicyOutput(ctx *pulumi.Context, args LookupListingIamPolicyOutputArgs, opts ...pulumi.InvokeOption) LookupListingIamPolicyResultOutput

func (LookupListingIamPolicyResultOutput) DataExchangeId 

func (o LookupListingIamPolicyResultOutput) DataExchangeId() pulumi.StringOutput

func (LookupListingIamPolicyResultOutput) ElementType 

func (LookupListingIamPolicyResultOutput) ElementType() reflect.Type

func (LookupListingIamPolicyResultOutput) Etag 

func (o LookupListingIamPolicyResultOutput) Etag() pulumi.StringOutput

(Computed) The etag of the IAM policy.

func (LookupListingIamPolicyResultOutput) Id 

func (o LookupListingIamPolicyResultOutput) Id() pulumi.StringOutput

The provider-assigned unique ID for this managed resource.

func (LookupListingIamPolicyResultOutput) ListingId 

func (o LookupListingIamPolicyResultOutput) ListingId() pulumi.StringOutput

func (LookupListingIamPolicyResultOutput) Location 

func (o LookupListingIamPolicyResultOutput) Location() pulumi.StringOutput

func (LookupListingIamPolicyResultOutput) PolicyData 

func (o LookupListingIamPolicyResultOutput) PolicyData() pulumi.StringOutput

(Required only by `bigqueryanalyticshub.ListingIamPolicy`) The policy data generated by a `organizations.getIAMPolicy` data source.

func (LookupListingIamPolicyResultOutput) Project 

func (o LookupListingIamPolicyResultOutput) Project() pulumi.StringOutput

func (LookupListingIamPolicyResultOutput) ToLookupListingIamPolicyResultOutput 

func (o LookupListingIamPolicyResultOutput) ToLookupListingIamPolicyResultOutput() LookupListingIamPolicyResultOutput

func (LookupListingIamPolicyResultOutput) ToLookupListingIamPolicyResultOutputWithContext 

func (o LookupListingIamPolicyResultOutput) ToLookupListingIamPolicyResultOutputWithContext(ctx context.Context) LookupListingIamPolicyResultOutput

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.