All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.pulumi.gcp.bigqueryanalyticshub.kotlin.ListingArgs.kt Maven / Gradle / Ivy

Go to download

Build cloud applications and infrastructure by combining the safety and reliability of infrastructure as code with the power of the Kotlin programming language.

There is a newer version: 8.12.0.0
Show newest version
@file:Suppress("NAME_SHADOWING", "DEPRECATION")

package com.pulumi.gcp.bigqueryanalyticshub.kotlin

import com.pulumi.core.Output
import com.pulumi.core.Output.of
import com.pulumi.gcp.bigqueryanalyticshub.ListingArgs.builder
import com.pulumi.gcp.bigqueryanalyticshub.kotlin.inputs.ListingBigqueryDatasetArgs
import com.pulumi.gcp.bigqueryanalyticshub.kotlin.inputs.ListingBigqueryDatasetArgsBuilder
import com.pulumi.gcp.bigqueryanalyticshub.kotlin.inputs.ListingDataProviderArgs
import com.pulumi.gcp.bigqueryanalyticshub.kotlin.inputs.ListingDataProviderArgsBuilder
import com.pulumi.gcp.bigqueryanalyticshub.kotlin.inputs.ListingPublisherArgs
import com.pulumi.gcp.bigqueryanalyticshub.kotlin.inputs.ListingPublisherArgsBuilder
import com.pulumi.gcp.bigqueryanalyticshub.kotlin.inputs.ListingRestrictedExportConfigArgs
import com.pulumi.gcp.bigqueryanalyticshub.kotlin.inputs.ListingRestrictedExportConfigArgsBuilder
import com.pulumi.kotlin.ConvertibleToJava
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.applySuspend
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.jvm.JvmName

/**
 * 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
 *     * [Official Documentation](https://cloud.google.com/bigquery/docs/analytics-hub-introduction)
 * ## Example Usage
 * ### Bigquery Analyticshub Listing Basic
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const listing = new gcp.bigqueryanalyticshub.DataExchange("listing", {
 *     location: "US",
 *     dataExchangeId: "my_data_exchange",
 *     displayName: "my_data_exchange",
 *     description: "example data exchange",
 * });
 * const listingDataset = new gcp.bigquery.Dataset("listing", {
 *     datasetId: "my_listing",
 *     friendlyName: "my_listing",
 *     description: "example data exchange",
 *     location: "US",
 * });
 * const listingListing = new gcp.bigqueryanalyticshub.Listing("listing", {
 *     location: "US",
 *     dataExchangeId: listing.dataExchangeId,
 *     listingId: "my_listing",
 *     displayName: "my_listing",
 *     description: "example data exchange",
 *     bigqueryDataset: {
 *         dataset: listingDataset.id,
 *     },
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * listing = gcp.bigqueryanalyticshub.DataExchange("listing",
 *     location="US",
 *     data_exchange_id="my_data_exchange",
 *     display_name="my_data_exchange",
 *     description="example data exchange")
 * listing_dataset = gcp.bigquery.Dataset("listing",
 *     dataset_id="my_listing",
 *     friendly_name="my_listing",
 *     description="example data exchange",
 *     location="US")
 * listing_listing = gcp.bigqueryanalyticshub.Listing("listing",
 *     location="US",
 *     data_exchange_id=listing.data_exchange_id,
 *     listing_id="my_listing",
 *     display_name="my_listing",
 *     description="example data exchange",
 *     bigquery_dataset=gcp.bigqueryanalyticshub.ListingBigqueryDatasetArgs(
 *         dataset=listing_dataset.id,
 *     ))
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var listing = new Gcp.BigQueryAnalyticsHub.DataExchange("listing", new()
 *     {
 *         Location = "US",
 *         DataExchangeId = "my_data_exchange",
 *         DisplayName = "my_data_exchange",
 *         Description = "example data exchange",
 *     });
 *     var listingDataset = new Gcp.BigQuery.Dataset("listing", new()
 *     {
 *         DatasetId = "my_listing",
 *         FriendlyName = "my_listing",
 *         Description = "example data exchange",
 *         Location = "US",
 *     });
 *     var listingListing = new Gcp.BigQueryAnalyticsHub.Listing("listing", new()
 *     {
 *         Location = "US",
 *         DataExchangeId = listing.DataExchangeId,
 *         ListingId = "my_listing",
 *         DisplayName = "my_listing",
 *         Description = "example data exchange",
 *         BigqueryDataset = new Gcp.BigQueryAnalyticsHub.Inputs.ListingBigqueryDatasetArgs
 *         {
 *             Dataset = listingDataset.Id,
 *         },
 *     });
 * });
 * ```
 * ```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
 * 	})
 * }
 * ```
 * ```java
 * package generated_program;
 * import com.pulumi.Context;
 * import com.pulumi.Pulumi;
 * import com.pulumi.core.Output;
 * import com.pulumi.gcp.bigqueryanalyticshub.DataExchange;
 * import com.pulumi.gcp.bigqueryanalyticshub.DataExchangeArgs;
 * import com.pulumi.gcp.bigquery.Dataset;
 * import com.pulumi.gcp.bigquery.DatasetArgs;
 * import com.pulumi.gcp.bigqueryanalyticshub.Listing;
 * import com.pulumi.gcp.bigqueryanalyticshub.ListingArgs;
 * import com.pulumi.gcp.bigqueryanalyticshub.inputs.ListingBigqueryDatasetArgs;
 * import java.util.List;
 * import java.util.ArrayList;
 * import java.util.Map;
 * import java.io.File;
 * import java.nio.file.Files;
 * import java.nio.file.Paths;
 * public class App {
 *     public static void main(String[] args) {
 *         Pulumi.run(App::stack);
 *     }
 *     public static void stack(Context ctx) {
 *         var listing = new DataExchange("listing", DataExchangeArgs.builder()
 *             .location("US")
 *             .dataExchangeId("my_data_exchange")
 *             .displayName("my_data_exchange")
 *             .description("example data exchange")
 *             .build());
 *         var listingDataset = new Dataset("listingDataset", DatasetArgs.builder()
 *             .datasetId("my_listing")
 *             .friendlyName("my_listing")
 *             .description("example data exchange")
 *             .location("US")
 *             .build());
 *         var listingListing = new Listing("listingListing", ListingArgs.builder()
 *             .location("US")
 *             .dataExchangeId(listing.dataExchangeId())
 *             .listingId("my_listing")
 *             .displayName("my_listing")
 *             .description("example data exchange")
 *             .bigqueryDataset(ListingBigqueryDatasetArgs.builder()
 *                 .dataset(listingDataset.id())
 *                 .build())
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   listing:
 *     type: gcp:bigqueryanalyticshub:DataExchange
 *     properties:
 *       location: US
 *       dataExchangeId: my_data_exchange
 *       displayName: my_data_exchange
 *       description: example data exchange
 *   listingListing:
 *     type: gcp:bigqueryanalyticshub:Listing
 *     name: listing
 *     properties:
 *       location: US
 *       dataExchangeId: ${listing.dataExchangeId}
 *       listingId: my_listing
 *       displayName: my_listing
 *       description: example data exchange
 *       bigqueryDataset:
 *         dataset: ${listingDataset.id}
 *   listingDataset:
 *     type: gcp:bigquery:Dataset
 *     name: listing
 *     properties:
 *       datasetId: my_listing
 *       friendlyName: my_listing
 *       description: example data exchange
 *       location: US
 * ```
 * 
 * ### Bigquery Analyticshub Listing Restricted
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const listing = new gcp.bigqueryanalyticshub.DataExchange("listing", {
 *     location: "US",
 *     dataExchangeId: "my_data_exchange",
 *     displayName: "my_data_exchange",
 *     description: "example data exchange",
 * });
 * const listingDataset = new gcp.bigquery.Dataset("listing", {
 *     datasetId: "my_listing",
 *     friendlyName: "my_listing",
 *     description: "example data exchange",
 *     location: "US",
 * });
 * const listingListing = new gcp.bigqueryanalyticshub.Listing("listing", {
 *     location: "US",
 *     dataExchangeId: listing.dataExchangeId,
 *     listingId: "my_listing",
 *     displayName: "my_listing",
 *     description: "example data exchange",
 *     bigqueryDataset: {
 *         dataset: listingDataset.id,
 *     },
 *     restrictedExportConfig: {
 *         enabled: true,
 *         restrictQueryResult: true,
 *     },
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * listing = gcp.bigqueryanalyticshub.DataExchange("listing",
 *     location="US",
 *     data_exchange_id="my_data_exchange",
 *     display_name="my_data_exchange",
 *     description="example data exchange")
 * listing_dataset = gcp.bigquery.Dataset("listing",
 *     dataset_id="my_listing",
 *     friendly_name="my_listing",
 *     description="example data exchange",
 *     location="US")
 * listing_listing = gcp.bigqueryanalyticshub.Listing("listing",
 *     location="US",
 *     data_exchange_id=listing.data_exchange_id,
 *     listing_id="my_listing",
 *     display_name="my_listing",
 *     description="example data exchange",
 *     bigquery_dataset=gcp.bigqueryanalyticshub.ListingBigqueryDatasetArgs(
 *         dataset=listing_dataset.id,
 *     ),
 *     restricted_export_config=gcp.bigqueryanalyticshub.ListingRestrictedExportConfigArgs(
 *         enabled=True,
 *         restrict_query_result=True,
 *     ))
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var listing = new Gcp.BigQueryAnalyticsHub.DataExchange("listing", new()
 *     {
 *         Location = "US",
 *         DataExchangeId = "my_data_exchange",
 *         DisplayName = "my_data_exchange",
 *         Description = "example data exchange",
 *     });
 *     var listingDataset = new Gcp.BigQuery.Dataset("listing", new()
 *     {
 *         DatasetId = "my_listing",
 *         FriendlyName = "my_listing",
 *         Description = "example data exchange",
 *         Location = "US",
 *     });
 *     var listingListing = new Gcp.BigQueryAnalyticsHub.Listing("listing", new()
 *     {
 *         Location = "US",
 *         DataExchangeId = listing.DataExchangeId,
 *         ListingId = "my_listing",
 *         DisplayName = "my_listing",
 *         Description = "example data exchange",
 *         BigqueryDataset = new Gcp.BigQueryAnalyticsHub.Inputs.ListingBigqueryDatasetArgs
 *         {
 *             Dataset = listingDataset.Id,
 *         },
 *         RestrictedExportConfig = new Gcp.BigQueryAnalyticsHub.Inputs.ListingRestrictedExportConfigArgs
 *         {
 *             Enabled = true,
 *             RestrictQueryResult = true,
 *         },
 *     });
 * });
 * ```
 * ```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
 * 	})
 * }
 * ```
 * ```java
 * package generated_program;
 * import com.pulumi.Context;
 * import com.pulumi.Pulumi;
 * import com.pulumi.core.Output;
 * import com.pulumi.gcp.bigqueryanalyticshub.DataExchange;
 * import com.pulumi.gcp.bigqueryanalyticshub.DataExchangeArgs;
 * import com.pulumi.gcp.bigquery.Dataset;
 * import com.pulumi.gcp.bigquery.DatasetArgs;
 * import com.pulumi.gcp.bigqueryanalyticshub.Listing;
 * import com.pulumi.gcp.bigqueryanalyticshub.ListingArgs;
 * import com.pulumi.gcp.bigqueryanalyticshub.inputs.ListingBigqueryDatasetArgs;
 * import com.pulumi.gcp.bigqueryanalyticshub.inputs.ListingRestrictedExportConfigArgs;
 * import java.util.List;
 * import java.util.ArrayList;
 * import java.util.Map;
 * import java.io.File;
 * import java.nio.file.Files;
 * import java.nio.file.Paths;
 * public class App {
 *     public static void main(String[] args) {
 *         Pulumi.run(App::stack);
 *     }
 *     public static void stack(Context ctx) {
 *         var listing = new DataExchange("listing", DataExchangeArgs.builder()
 *             .location("US")
 *             .dataExchangeId("my_data_exchange")
 *             .displayName("my_data_exchange")
 *             .description("example data exchange")
 *             .build());
 *         var listingDataset = new Dataset("listingDataset", DatasetArgs.builder()
 *             .datasetId("my_listing")
 *             .friendlyName("my_listing")
 *             .description("example data exchange")
 *             .location("US")
 *             .build());
 *         var listingListing = new Listing("listingListing", ListingArgs.builder()
 *             .location("US")
 *             .dataExchangeId(listing.dataExchangeId())
 *             .listingId("my_listing")
 *             .displayName("my_listing")
 *             .description("example data exchange")
 *             .bigqueryDataset(ListingBigqueryDatasetArgs.builder()
 *                 .dataset(listingDataset.id())
 *                 .build())
 *             .restrictedExportConfig(ListingRestrictedExportConfigArgs.builder()
 *                 .enabled(true)
 *                 .restrictQueryResult(true)
 *                 .build())
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   listing:
 *     type: gcp:bigqueryanalyticshub:DataExchange
 *     properties:
 *       location: US
 *       dataExchangeId: my_data_exchange
 *       displayName: my_data_exchange
 *       description: example data exchange
 *   listingListing:
 *     type: gcp:bigqueryanalyticshub:Listing
 *     name: listing
 *     properties:
 *       location: US
 *       dataExchangeId: ${listing.dataExchangeId}
 *       listingId: my_listing
 *       displayName: my_listing
 *       description: example data exchange
 *       bigqueryDataset:
 *         dataset: ${listingDataset.id}
 *       restrictedExportConfig:
 *         enabled: true
 *         restrictQueryResult: true
 *   listingDataset:
 *     type: gcp:bigquery:Dataset
 *     name: listing
 *     properties:
 *       datasetId: my_listing
 *       friendlyName: my_listing
 *       description: example data exchange
 *       location: US
 * ```
 * 
 * ## 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}}
 * ```
 * @property bigqueryDataset Shared dataset i.e. BigQuery dataset source.
 * Structure is documented below.
 * @property categories Categories of the listing. Up to two categories are allowed.
 * @property dataExchangeId 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.
 * @property dataProvider Details of the data provider who owns the source data.
 * @property description 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).
 * @property displayName 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.
 * @property documentation Documentation describing the listing.
 * @property icon Base64 encoded image representing the listing.
 * @property listingId 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.
 * @property location The name of the location this data exchange listing.
 * @property primaryContact Email or URL of the primary point of contact of the listing.
 * @property project
 * @property publisher Details of the publisher who owns the listing and who can share the source data.
 * @property requestAccess Email or URL of the request access of the listing. Subscribers can use this reference to request access.
 * @property restrictedExportConfig If set, restricted export configuration will be propagated and enforced on the linked dataset.
 */
public data class ListingArgs(
    public val bigqueryDataset: Output? = null,
    public val categories: Output>? = null,
    public val dataExchangeId: Output? = null,
    public val dataProvider: Output? = null,
    public val description: Output? = null,
    public val displayName: Output? = null,
    public val documentation: Output? = null,
    public val icon: Output? = null,
    public val listingId: Output? = null,
    public val location: Output? = null,
    public val primaryContact: Output? = null,
    public val project: Output? = null,
    public val publisher: Output? = null,
    public val requestAccess: Output? = null,
    public val restrictedExportConfig: Output? = null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.gcp.bigqueryanalyticshub.ListingArgs =
        com.pulumi.gcp.bigqueryanalyticshub.ListingArgs.builder()
            .bigqueryDataset(bigqueryDataset?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .categories(categories?.applyValue({ args0 -> args0.map({ args0 -> args0 }) }))
            .dataExchangeId(dataExchangeId?.applyValue({ args0 -> args0 }))
            .dataProvider(dataProvider?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .description(description?.applyValue({ args0 -> args0 }))
            .displayName(displayName?.applyValue({ args0 -> args0 }))
            .documentation(documentation?.applyValue({ args0 -> args0 }))
            .icon(icon?.applyValue({ args0 -> args0 }))
            .listingId(listingId?.applyValue({ args0 -> args0 }))
            .location(location?.applyValue({ args0 -> args0 }))
            .primaryContact(primaryContact?.applyValue({ args0 -> args0 }))
            .project(project?.applyValue({ args0 -> args0 }))
            .publisher(publisher?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .requestAccess(requestAccess?.applyValue({ args0 -> args0 }))
            .restrictedExportConfig(
                restrictedExportConfig?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            ).build()
}

/**
 * Builder for [ListingArgs].
 */
@PulumiTagMarker
public class ListingArgsBuilder internal constructor() {
    private var bigqueryDataset: Output? = null

    private var categories: Output>? = null

    private var dataExchangeId: Output? = null

    private var dataProvider: Output? = null

    private var description: Output? = null

    private var displayName: Output? = null

    private var documentation: Output? = null

    private var icon: Output? = null

    private var listingId: Output? = null

    private var location: Output? = null

    private var primaryContact: Output? = null

    private var project: Output? = null

    private var publisher: Output? = null

    private var requestAccess: Output? = null

    private var restrictedExportConfig: Output? = null

    /**
     * @param value Shared dataset i.e. BigQuery dataset source.
     * Structure is documented below.
     */
    @JvmName("yojxdsmphbclytto")
    public suspend fun bigqueryDataset(`value`: Output) {
        this.bigqueryDataset = value
    }

    /**
     * @param value Categories of the listing. Up to two categories are allowed.
     */
    @JvmName("owvijjdpnlyrecdb")
    public suspend fun categories(`value`: Output>) {
        this.categories = value
    }

    @JvmName("icvhgstoorvjbysr")
    public suspend fun categories(vararg values: Output) {
        this.categories = Output.all(values.asList())
    }

    /**
     * @param values Categories of the listing. Up to two categories are allowed.
     */
    @JvmName("fotxbgiaejnmwjvf")
    public suspend fun categories(values: List>) {
        this.categories = Output.all(values)
    }

    /**
     * @param value 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.
     */
    @JvmName("hclbldvaugbovpyc")
    public suspend fun dataExchangeId(`value`: Output) {
        this.dataExchangeId = value
    }

    /**
     * @param value Details of the data provider who owns the source data.
     */
    @JvmName("yykbmatbxftdmqtv")
    public suspend fun dataProvider(`value`: Output) {
        this.dataProvider = value
    }

    /**
     * @param value 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).
     */
    @JvmName("ujarajoklrcdvrrs")
    public suspend fun description(`value`: Output) {
        this.description = value
    }

    /**
     * @param value 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.
     */
    @JvmName("jqkcraivpymtpyti")
    public suspend fun displayName(`value`: Output) {
        this.displayName = value
    }

    /**
     * @param value Documentation describing the listing.
     */
    @JvmName("egyihkfrcoidqbym")
    public suspend fun documentation(`value`: Output) {
        this.documentation = value
    }

    /**
     * @param value Base64 encoded image representing the listing.
     */
    @JvmName("ohfwkxcngyducont")
    public suspend fun icon(`value`: Output) {
        this.icon = value
    }

    /**
     * @param value 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.
     */
    @JvmName("trbpqikqqguobuur")
    public suspend fun listingId(`value`: Output) {
        this.listingId = value
    }

    /**
     * @param value The name of the location this data exchange listing.
     */
    @JvmName("svptbgaojqpfvlfm")
    public suspend fun location(`value`: Output) {
        this.location = value
    }

    /**
     * @param value Email or URL of the primary point of contact of the listing.
     */
    @JvmName("uxeqhrvhurvbfvbb")
    public suspend fun primaryContact(`value`: Output) {
        this.primaryContact = value
    }

    /**
     * @param value
     */
    @JvmName("caxbfemlwokqxxjw")
    public suspend fun project(`value`: Output) {
        this.project = value
    }

    /**
     * @param value Details of the publisher who owns the listing and who can share the source data.
     */
    @JvmName("hrgoehixkmvxcahr")
    public suspend fun publisher(`value`: Output) {
        this.publisher = value
    }

    /**
     * @param value Email or URL of the request access of the listing. Subscribers can use this reference to request access.
     */
    @JvmName("roqmpsxjkaghgwep")
    public suspend fun requestAccess(`value`: Output) {
        this.requestAccess = value
    }

    /**
     * @param value If set, restricted export configuration will be propagated and enforced on the linked dataset.
     */
    @JvmName("koihhpwggfjahois")
    public suspend fun restrictedExportConfig(`value`: Output) {
        this.restrictedExportConfig = value
    }

    /**
     * @param value Shared dataset i.e. BigQuery dataset source.
     * Structure is documented below.
     */
    @JvmName("uqqmwunhsiaxnnoo")
    public suspend fun bigqueryDataset(`value`: ListingBigqueryDatasetArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.bigqueryDataset = mapped
    }

    /**
     * @param argument Shared dataset i.e. BigQuery dataset source.
     * Structure is documented below.
     */
    @JvmName("frjkegkiwydrsryw")
    public suspend fun bigqueryDataset(argument: suspend ListingBigqueryDatasetArgsBuilder.() -> Unit) {
        val toBeMapped = ListingBigqueryDatasetArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.bigqueryDataset = mapped
    }

    /**
     * @param value Categories of the listing. Up to two categories are allowed.
     */
    @JvmName("ggpgsxsusbqogplk")
    public suspend fun categories(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.categories = mapped
    }

    /**
     * @param values Categories of the listing. Up to two categories are allowed.
     */
    @JvmName("bcfjouycnllowckv")
    public suspend fun categories(vararg values: String) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.categories = mapped
    }

    /**
     * @param value 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.
     */
    @JvmName("hgprwswgtuischfj")
    public suspend fun dataExchangeId(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.dataExchangeId = mapped
    }

    /**
     * @param value Details of the data provider who owns the source data.
     */
    @JvmName("nmreuydgdiuhcfnp")
    public suspend fun dataProvider(`value`: ListingDataProviderArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.dataProvider = mapped
    }

    /**
     * @param argument Details of the data provider who owns the source data.
     */
    @JvmName("yaaiupmtyfnhsehy")
    public suspend fun dataProvider(argument: suspend ListingDataProviderArgsBuilder.() -> Unit) {
        val toBeMapped = ListingDataProviderArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.dataProvider = mapped
    }

    /**
     * @param value 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).
     */
    @JvmName("vsmgyokyjyingdet")
    public suspend fun description(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.description = mapped
    }

    /**
     * @param value 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.
     */
    @JvmName("gtorqlccimdvjfau")
    public suspend fun displayName(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.displayName = mapped
    }

    /**
     * @param value Documentation describing the listing.
     */
    @JvmName("dsctqyaavjcjtbme")
    public suspend fun documentation(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.documentation = mapped
    }

    /**
     * @param value Base64 encoded image representing the listing.
     */
    @JvmName("wswrujctvpyfuyug")
    public suspend fun icon(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.icon = mapped
    }

    /**
     * @param value 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.
     */
    @JvmName("txtbuxafjdfsgyyl")
    public suspend fun listingId(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.listingId = mapped
    }

    /**
     * @param value The name of the location this data exchange listing.
     */
    @JvmName("nxeshkrsmqjbemgl")
    public suspend fun location(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.location = mapped
    }

    /**
     * @param value Email or URL of the primary point of contact of the listing.
     */
    @JvmName("avtecllcptnyjjex")
    public suspend fun primaryContact(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.primaryContact = mapped
    }

    /**
     * @param value
     */
    @JvmName("ogcfdhfhwagphokv")
    public suspend fun project(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.project = mapped
    }

    /**
     * @param value Details of the publisher who owns the listing and who can share the source data.
     */
    @JvmName("fploitkkojrsjpmu")
    public suspend fun publisher(`value`: ListingPublisherArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.publisher = mapped
    }

    /**
     * @param argument Details of the publisher who owns the listing and who can share the source data.
     */
    @JvmName("khfxvynnweaeedcg")
    public suspend fun publisher(argument: suspend ListingPublisherArgsBuilder.() -> Unit) {
        val toBeMapped = ListingPublisherArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.publisher = mapped
    }

    /**
     * @param value Email or URL of the request access of the listing. Subscribers can use this reference to request access.
     */
    @JvmName("nrljhacsggldgjob")
    public suspend fun requestAccess(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.requestAccess = mapped
    }

    /**
     * @param value If set, restricted export configuration will be propagated and enforced on the linked dataset.
     */
    @JvmName("rsatlsycplbbwfxt")
    public suspend fun restrictedExportConfig(`value`: ListingRestrictedExportConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.restrictedExportConfig = mapped
    }

    /**
     * @param argument If set, restricted export configuration will be propagated and enforced on the linked dataset.
     */
    @JvmName("rxjfmemjxdhgcybu")
    public suspend fun restrictedExportConfig(argument: suspend ListingRestrictedExportConfigArgsBuilder.() -> Unit) {
        val toBeMapped = ListingRestrictedExportConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.restrictedExportConfig = mapped
    }

    internal fun build(): ListingArgs = ListingArgs(
        bigqueryDataset = bigqueryDataset,
        categories = categories,
        dataExchangeId = dataExchangeId,
        dataProvider = dataProvider,
        description = description,
        displayName = displayName,
        documentation = documentation,
        icon = icon,
        listingId = listingId,
        location = location,
        primaryContact = primaryContact,
        project = project,
        publisher = publisher,
        requestAccess = requestAccess,
        restrictedExportConfig = restrictedExportConfig,
    )
}




© 2015 - 2025 Weber Informatics LLC | Privacy Policy