pulumiTypes.go

// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT.
// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***

package lakeformation

import (
	"context"
	"reflect"

	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/internal"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

var _ = internal.GetEnvOrDefault

type DataCellsFilterTableData struct {
	// A list of column names and/or nested column attributes.
	ColumnNames    []string                                `pulumi:"columnNames"`
	ColumnWildcard *DataCellsFilterTableDataColumnWildcard `pulumi:"columnWildcard"`
	// The name of the database.
	DatabaseName string `pulumi:"databaseName"`
	// The name of the data cells filter.
	Name string `pulumi:"name"`
	// A PartiQL predicate. See Row Filter below for details.
	RowFilter *DataCellsFilterTableDataRowFilter `pulumi:"rowFilter"`
	// The ID of the Data Catalog.
	TableCatalogId string `pulumi:"tableCatalogId"`
	// The name of the table.
	TableName string `pulumi:"tableName"`
	// ID of the data cells filter version.
	VersionId *string `pulumi:"versionId"`
}

// DataCellsFilterTableDataInput is an input type that accepts DataCellsFilterTableDataArgs and DataCellsFilterTableDataOutput values.
// You can construct a concrete instance of `DataCellsFilterTableDataInput` via:
//
//	DataCellsFilterTableDataArgs{...}
type DataCellsFilterTableDataInput interface {
	pulumi.Input

	ToDataCellsFilterTableDataOutput() DataCellsFilterTableDataOutput
	ToDataCellsFilterTableDataOutputWithContext(context.Context) DataCellsFilterTableDataOutput
}

type DataCellsFilterTableDataArgs struct {
	// A list of column names and/or nested column attributes.
	ColumnNames    pulumi.StringArrayInput                        `pulumi:"columnNames"`
	ColumnWildcard DataCellsFilterTableDataColumnWildcardPtrInput `pulumi:"columnWildcard"`
	// The name of the database.
	DatabaseName pulumi.StringInput `pulumi:"databaseName"`
	// The name of the data cells filter.
	Name pulumi.StringInput `pulumi:"name"`
	// A PartiQL predicate. See Row Filter below for details.
	RowFilter DataCellsFilterTableDataRowFilterPtrInput `pulumi:"rowFilter"`
	// The ID of the Data Catalog.
	TableCatalogId pulumi.StringInput `pulumi:"tableCatalogId"`
	// The name of the table.
	TableName pulumi.StringInput `pulumi:"tableName"`
	// ID of the data cells filter version.
	VersionId pulumi.StringPtrInput `pulumi:"versionId"`
}

func (DataCellsFilterTableDataArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*DataCellsFilterTableData)(nil)).Elem()
}

func (i DataCellsFilterTableDataArgs) ToDataCellsFilterTableDataOutput() DataCellsFilterTableDataOutput {
	return i.ToDataCellsFilterTableDataOutputWithContext(context.Background())
}

func (i DataCellsFilterTableDataArgs) ToDataCellsFilterTableDataOutputWithContext(ctx context.Context) DataCellsFilterTableDataOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DataCellsFilterTableDataOutput)
}

func (i DataCellsFilterTableDataArgs) ToDataCellsFilterTableDataPtrOutput() DataCellsFilterTableDataPtrOutput {
	return i.ToDataCellsFilterTableDataPtrOutputWithContext(context.Background())
}

func (i DataCellsFilterTableDataArgs) ToDataCellsFilterTableDataPtrOutputWithContext(ctx context.Context) DataCellsFilterTableDataPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DataCellsFilterTableDataOutput).ToDataCellsFilterTableDataPtrOutputWithContext(ctx)
}

// DataCellsFilterTableDataPtrInput is an input type that accepts DataCellsFilterTableDataArgs, DataCellsFilterTableDataPtr and DataCellsFilterTableDataPtrOutput values.
// You can construct a concrete instance of `DataCellsFilterTableDataPtrInput` via:
//
//	        DataCellsFilterTableDataArgs{...}
//
//	or:
//
//	        nil
type DataCellsFilterTableDataPtrInput interface {
	pulumi.Input

	ToDataCellsFilterTableDataPtrOutput() DataCellsFilterTableDataPtrOutput
	ToDataCellsFilterTableDataPtrOutputWithContext(context.Context) DataCellsFilterTableDataPtrOutput
}

type dataCellsFilterTableDataPtrType DataCellsFilterTableDataArgs

func DataCellsFilterTableDataPtr(v *DataCellsFilterTableDataArgs) DataCellsFilterTableDataPtrInput {
	return (*dataCellsFilterTableDataPtrType)(v)
}

func (*dataCellsFilterTableDataPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**DataCellsFilterTableData)(nil)).Elem()
}

func (i *dataCellsFilterTableDataPtrType) ToDataCellsFilterTableDataPtrOutput() DataCellsFilterTableDataPtrOutput {
	return i.ToDataCellsFilterTableDataPtrOutputWithContext(context.Background())
}

func (i *dataCellsFilterTableDataPtrType) ToDataCellsFilterTableDataPtrOutputWithContext(ctx context.Context) DataCellsFilterTableDataPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DataCellsFilterTableDataPtrOutput)
}

type DataCellsFilterTableDataOutput struct{ *pulumi.OutputState }

func (DataCellsFilterTableDataOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*DataCellsFilterTableData)(nil)).Elem()
}

func (o DataCellsFilterTableDataOutput) ToDataCellsFilterTableDataOutput() DataCellsFilterTableDataOutput {
	return o
}

func (o DataCellsFilterTableDataOutput) ToDataCellsFilterTableDataOutputWithContext(ctx context.Context) DataCellsFilterTableDataOutput {
	return o
}

func (o DataCellsFilterTableDataOutput) ToDataCellsFilterTableDataPtrOutput() DataCellsFilterTableDataPtrOutput {
	return o.ToDataCellsFilterTableDataPtrOutputWithContext(context.Background())
}

func (o DataCellsFilterTableDataOutput) ToDataCellsFilterTableDataPtrOutputWithContext(ctx context.Context) DataCellsFilterTableDataPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v DataCellsFilterTableData) *DataCellsFilterTableData {
		return &v
	}).(DataCellsFilterTableDataPtrOutput)
}

// A list of column names and/or nested column attributes.
func (o DataCellsFilterTableDataOutput) ColumnNames() pulumi.StringArrayOutput {
	return o.ApplyT(func(v DataCellsFilterTableData) []string { return v.ColumnNames }).(pulumi.StringArrayOutput)
}

func (o DataCellsFilterTableDataOutput) ColumnWildcard() DataCellsFilterTableDataColumnWildcardPtrOutput {
	return o.ApplyT(func(v DataCellsFilterTableData) *DataCellsFilterTableDataColumnWildcard { return v.ColumnWildcard }).(DataCellsFilterTableDataColumnWildcardPtrOutput)
}

// The name of the database.
func (o DataCellsFilterTableDataOutput) DatabaseName() pulumi.StringOutput {
	return o.ApplyT(func(v DataCellsFilterTableData) string { return v.DatabaseName }).(pulumi.StringOutput)
}

// The name of the data cells filter.
func (o DataCellsFilterTableDataOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v DataCellsFilterTableData) string { return v.Name }).(pulumi.StringOutput)
}

// A PartiQL predicate. See Row Filter below for details.
func (o DataCellsFilterTableDataOutput) RowFilter() DataCellsFilterTableDataRowFilterPtrOutput {
	return o.ApplyT(func(v DataCellsFilterTableData) *DataCellsFilterTableDataRowFilter { return v.RowFilter }).(DataCellsFilterTableDataRowFilterPtrOutput)
}

// The ID of the Data Catalog.
func (o DataCellsFilterTableDataOutput) TableCatalogId() pulumi.StringOutput {
	return o.ApplyT(func(v DataCellsFilterTableData) string { return v.TableCatalogId }).(pulumi.StringOutput)
}

// The name of the table.
func (o DataCellsFilterTableDataOutput) TableName() pulumi.StringOutput {
	return o.ApplyT(func(v DataCellsFilterTableData) string { return v.TableName }).(pulumi.StringOutput)
}

// ID of the data cells filter version.
func (o DataCellsFilterTableDataOutput) VersionId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v DataCellsFilterTableData) *string { return v.VersionId }).(pulumi.StringPtrOutput)
}

type DataCellsFilterTableDataPtrOutput struct{ *pulumi.OutputState }

func (DataCellsFilterTableDataPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**DataCellsFilterTableData)(nil)).Elem()
}

func (o DataCellsFilterTableDataPtrOutput) ToDataCellsFilterTableDataPtrOutput() DataCellsFilterTableDataPtrOutput {
	return o
}

func (o DataCellsFilterTableDataPtrOutput) ToDataCellsFilterTableDataPtrOutputWithContext(ctx context.Context) DataCellsFilterTableDataPtrOutput {
	return o
}

func (o DataCellsFilterTableDataPtrOutput) Elem() DataCellsFilterTableDataOutput {
	return o.ApplyT(func(v *DataCellsFilterTableData) DataCellsFilterTableData {
		if v != nil {
			return *v
		}
		var ret DataCellsFilterTableData
		return ret
	}).(DataCellsFilterTableDataOutput)
}

// A list of column names and/or nested column attributes.
func (o DataCellsFilterTableDataPtrOutput) ColumnNames() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *DataCellsFilterTableData) []string {
		if v == nil {
			return nil
		}
		return v.ColumnNames
	}).(pulumi.StringArrayOutput)
}

func (o DataCellsFilterTableDataPtrOutput) ColumnWildcard() DataCellsFilterTableDataColumnWildcardPtrOutput {
	return o.ApplyT(func(v *DataCellsFilterTableData) *DataCellsFilterTableDataColumnWildcard {
		if v == nil {
			return nil
		}
		return v.ColumnWildcard
	}).(DataCellsFilterTableDataColumnWildcardPtrOutput)
}

// The name of the database.
func (o DataCellsFilterTableDataPtrOutput) DatabaseName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DataCellsFilterTableData) *string {
		if v == nil {
			return nil
		}
		return &v.DatabaseName
	}).(pulumi.StringPtrOutput)
}

// The name of the data cells filter.
func (o DataCellsFilterTableDataPtrOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DataCellsFilterTableData) *string {
		if v == nil {
			return nil
		}
		return &v.Name
	}).(pulumi.StringPtrOutput)
}

// A PartiQL predicate. See Row Filter below for details.
func (o DataCellsFilterTableDataPtrOutput) RowFilter() DataCellsFilterTableDataRowFilterPtrOutput {
	return o.ApplyT(func(v *DataCellsFilterTableData) *DataCellsFilterTableDataRowFilter {
		if v == nil {
			return nil
		}
		return v.RowFilter
	}).(DataCellsFilterTableDataRowFilterPtrOutput)
}

// The ID of the Data Catalog.
func (o DataCellsFilterTableDataPtrOutput) TableCatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DataCellsFilterTableData) *string {
		if v == nil {
			return nil
		}
		return &v.TableCatalogId
	}).(pulumi.StringPtrOutput)
}

// The name of the table.
func (o DataCellsFilterTableDataPtrOutput) TableName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DataCellsFilterTableData) *string {
		if v == nil {
			return nil
		}
		return &v.TableName
	}).(pulumi.StringPtrOutput)
}

// ID of the data cells filter version.
func (o DataCellsFilterTableDataPtrOutput) VersionId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DataCellsFilterTableData) *string {
		if v == nil {
			return nil
		}
		return v.VersionId
	}).(pulumi.StringPtrOutput)
}

type DataCellsFilterTableDataColumnWildcard struct {
	// (Optional) Excludes column names. Any column with this name will be excluded.
	ExcludedColumnNames []string `pulumi:"excludedColumnNames"`
}

// DataCellsFilterTableDataColumnWildcardInput is an input type that accepts DataCellsFilterTableDataColumnWildcardArgs and DataCellsFilterTableDataColumnWildcardOutput values.
// You can construct a concrete instance of `DataCellsFilterTableDataColumnWildcardInput` via:
//
//	DataCellsFilterTableDataColumnWildcardArgs{...}
type DataCellsFilterTableDataColumnWildcardInput interface {
	pulumi.Input

	ToDataCellsFilterTableDataColumnWildcardOutput() DataCellsFilterTableDataColumnWildcardOutput
	ToDataCellsFilterTableDataColumnWildcardOutputWithContext(context.Context) DataCellsFilterTableDataColumnWildcardOutput
}

type DataCellsFilterTableDataColumnWildcardArgs struct {
	// (Optional) Excludes column names. Any column with this name will be excluded.
	ExcludedColumnNames pulumi.StringArrayInput `pulumi:"excludedColumnNames"`
}

func (DataCellsFilterTableDataColumnWildcardArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*DataCellsFilterTableDataColumnWildcard)(nil)).Elem()
}

func (i DataCellsFilterTableDataColumnWildcardArgs) ToDataCellsFilterTableDataColumnWildcardOutput() DataCellsFilterTableDataColumnWildcardOutput {
	return i.ToDataCellsFilterTableDataColumnWildcardOutputWithContext(context.Background())
}

func (i DataCellsFilterTableDataColumnWildcardArgs) ToDataCellsFilterTableDataColumnWildcardOutputWithContext(ctx context.Context) DataCellsFilterTableDataColumnWildcardOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DataCellsFilterTableDataColumnWildcardOutput)
}

func (i DataCellsFilterTableDataColumnWildcardArgs) ToDataCellsFilterTableDataColumnWildcardPtrOutput() DataCellsFilterTableDataColumnWildcardPtrOutput {
	return i.ToDataCellsFilterTableDataColumnWildcardPtrOutputWithContext(context.Background())
}

func (i DataCellsFilterTableDataColumnWildcardArgs) ToDataCellsFilterTableDataColumnWildcardPtrOutputWithContext(ctx context.Context) DataCellsFilterTableDataColumnWildcardPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DataCellsFilterTableDataColumnWildcardOutput).ToDataCellsFilterTableDataColumnWildcardPtrOutputWithContext(ctx)
}

// DataCellsFilterTableDataColumnWildcardPtrInput is an input type that accepts DataCellsFilterTableDataColumnWildcardArgs, DataCellsFilterTableDataColumnWildcardPtr and DataCellsFilterTableDataColumnWildcardPtrOutput values.
// You can construct a concrete instance of `DataCellsFilterTableDataColumnWildcardPtrInput` via:
//
//	        DataCellsFilterTableDataColumnWildcardArgs{...}
//
//	or:
//
//	        nil
type DataCellsFilterTableDataColumnWildcardPtrInput interface {
	pulumi.Input

	ToDataCellsFilterTableDataColumnWildcardPtrOutput() DataCellsFilterTableDataColumnWildcardPtrOutput
	ToDataCellsFilterTableDataColumnWildcardPtrOutputWithContext(context.Context) DataCellsFilterTableDataColumnWildcardPtrOutput
}

type dataCellsFilterTableDataColumnWildcardPtrType DataCellsFilterTableDataColumnWildcardArgs

func DataCellsFilterTableDataColumnWildcardPtr(v *DataCellsFilterTableDataColumnWildcardArgs) DataCellsFilterTableDataColumnWildcardPtrInput {
	return (*dataCellsFilterTableDataColumnWildcardPtrType)(v)
}

func (*dataCellsFilterTableDataColumnWildcardPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**DataCellsFilterTableDataColumnWildcard)(nil)).Elem()
}

func (i *dataCellsFilterTableDataColumnWildcardPtrType) ToDataCellsFilterTableDataColumnWildcardPtrOutput() DataCellsFilterTableDataColumnWildcardPtrOutput {
	return i.ToDataCellsFilterTableDataColumnWildcardPtrOutputWithContext(context.Background())
}

func (i *dataCellsFilterTableDataColumnWildcardPtrType) ToDataCellsFilterTableDataColumnWildcardPtrOutputWithContext(ctx context.Context) DataCellsFilterTableDataColumnWildcardPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DataCellsFilterTableDataColumnWildcardPtrOutput)
}

type DataCellsFilterTableDataColumnWildcardOutput struct{ *pulumi.OutputState }

func (DataCellsFilterTableDataColumnWildcardOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*DataCellsFilterTableDataColumnWildcard)(nil)).Elem()
}

func (o DataCellsFilterTableDataColumnWildcardOutput) ToDataCellsFilterTableDataColumnWildcardOutput() DataCellsFilterTableDataColumnWildcardOutput {
	return o
}

func (o DataCellsFilterTableDataColumnWildcardOutput) ToDataCellsFilterTableDataColumnWildcardOutputWithContext(ctx context.Context) DataCellsFilterTableDataColumnWildcardOutput {
	return o
}

func (o DataCellsFilterTableDataColumnWildcardOutput) ToDataCellsFilterTableDataColumnWildcardPtrOutput() DataCellsFilterTableDataColumnWildcardPtrOutput {
	return o.ToDataCellsFilterTableDataColumnWildcardPtrOutputWithContext(context.Background())
}

func (o DataCellsFilterTableDataColumnWildcardOutput) ToDataCellsFilterTableDataColumnWildcardPtrOutputWithContext(ctx context.Context) DataCellsFilterTableDataColumnWildcardPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v DataCellsFilterTableDataColumnWildcard) *DataCellsFilterTableDataColumnWildcard {
		return &v
	}).(DataCellsFilterTableDataColumnWildcardPtrOutput)
}

// (Optional) Excludes column names. Any column with this name will be excluded.
func (o DataCellsFilterTableDataColumnWildcardOutput) ExcludedColumnNames() pulumi.StringArrayOutput {
	return o.ApplyT(func(v DataCellsFilterTableDataColumnWildcard) []string { return v.ExcludedColumnNames }).(pulumi.StringArrayOutput)
}

type DataCellsFilterTableDataColumnWildcardPtrOutput struct{ *pulumi.OutputState }

func (DataCellsFilterTableDataColumnWildcardPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**DataCellsFilterTableDataColumnWildcard)(nil)).Elem()
}

func (o DataCellsFilterTableDataColumnWildcardPtrOutput) ToDataCellsFilterTableDataColumnWildcardPtrOutput() DataCellsFilterTableDataColumnWildcardPtrOutput {
	return o
}

func (o DataCellsFilterTableDataColumnWildcardPtrOutput) ToDataCellsFilterTableDataColumnWildcardPtrOutputWithContext(ctx context.Context) DataCellsFilterTableDataColumnWildcardPtrOutput {
	return o
}

func (o DataCellsFilterTableDataColumnWildcardPtrOutput) Elem() DataCellsFilterTableDataColumnWildcardOutput {
	return o.ApplyT(func(v *DataCellsFilterTableDataColumnWildcard) DataCellsFilterTableDataColumnWildcard {
		if v != nil {
			return *v
		}
		var ret DataCellsFilterTableDataColumnWildcard
		return ret
	}).(DataCellsFilterTableDataColumnWildcardOutput)
}

// (Optional) Excludes column names. Any column with this name will be excluded.
func (o DataCellsFilterTableDataColumnWildcardPtrOutput) ExcludedColumnNames() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *DataCellsFilterTableDataColumnWildcard) []string {
		if v == nil {
			return nil
		}
		return v.ExcludedColumnNames
	}).(pulumi.StringArrayOutput)
}

type DataCellsFilterTableDataRowFilter struct {
	// (Optional) A wildcard that matches all rows.
	AllRowsWildcard *DataCellsFilterTableDataRowFilterAllRowsWildcard `pulumi:"allRowsWildcard"`
	// (Optional) A filter expression.
	FilterExpression *string `pulumi:"filterExpression"`
}

// DataCellsFilterTableDataRowFilterInput is an input type that accepts DataCellsFilterTableDataRowFilterArgs and DataCellsFilterTableDataRowFilterOutput values.
// You can construct a concrete instance of `DataCellsFilterTableDataRowFilterInput` via:
//
//	DataCellsFilterTableDataRowFilterArgs{...}
type DataCellsFilterTableDataRowFilterInput interface {
	pulumi.Input

	ToDataCellsFilterTableDataRowFilterOutput() DataCellsFilterTableDataRowFilterOutput
	ToDataCellsFilterTableDataRowFilterOutputWithContext(context.Context) DataCellsFilterTableDataRowFilterOutput
}

type DataCellsFilterTableDataRowFilterArgs struct {
	// (Optional) A wildcard that matches all rows.
	AllRowsWildcard DataCellsFilterTableDataRowFilterAllRowsWildcardPtrInput `pulumi:"allRowsWildcard"`
	// (Optional) A filter expression.
	FilterExpression pulumi.StringPtrInput `pulumi:"filterExpression"`
}

func (DataCellsFilterTableDataRowFilterArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*DataCellsFilterTableDataRowFilter)(nil)).Elem()
}

func (i DataCellsFilterTableDataRowFilterArgs) ToDataCellsFilterTableDataRowFilterOutput() DataCellsFilterTableDataRowFilterOutput {
	return i.ToDataCellsFilterTableDataRowFilterOutputWithContext(context.Background())
}

func (i DataCellsFilterTableDataRowFilterArgs) ToDataCellsFilterTableDataRowFilterOutputWithContext(ctx context.Context) DataCellsFilterTableDataRowFilterOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DataCellsFilterTableDataRowFilterOutput)
}

func (i DataCellsFilterTableDataRowFilterArgs) ToDataCellsFilterTableDataRowFilterPtrOutput() DataCellsFilterTableDataRowFilterPtrOutput {
	return i.ToDataCellsFilterTableDataRowFilterPtrOutputWithContext(context.Background())
}

func (i DataCellsFilterTableDataRowFilterArgs) ToDataCellsFilterTableDataRowFilterPtrOutputWithContext(ctx context.Context) DataCellsFilterTableDataRowFilterPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DataCellsFilterTableDataRowFilterOutput).ToDataCellsFilterTableDataRowFilterPtrOutputWithContext(ctx)
}

// DataCellsFilterTableDataRowFilterPtrInput is an input type that accepts DataCellsFilterTableDataRowFilterArgs, DataCellsFilterTableDataRowFilterPtr and DataCellsFilterTableDataRowFilterPtrOutput values.
// You can construct a concrete instance of `DataCellsFilterTableDataRowFilterPtrInput` via:
//
//	        DataCellsFilterTableDataRowFilterArgs{...}
//
//	or:
//
//	        nil
type DataCellsFilterTableDataRowFilterPtrInput interface {
	pulumi.Input

	ToDataCellsFilterTableDataRowFilterPtrOutput() DataCellsFilterTableDataRowFilterPtrOutput
	ToDataCellsFilterTableDataRowFilterPtrOutputWithContext(context.Context) DataCellsFilterTableDataRowFilterPtrOutput
}

type dataCellsFilterTableDataRowFilterPtrType DataCellsFilterTableDataRowFilterArgs

func DataCellsFilterTableDataRowFilterPtr(v *DataCellsFilterTableDataRowFilterArgs) DataCellsFilterTableDataRowFilterPtrInput {
	return (*dataCellsFilterTableDataRowFilterPtrType)(v)
}

func (*dataCellsFilterTableDataRowFilterPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**DataCellsFilterTableDataRowFilter)(nil)).Elem()
}

func (i *dataCellsFilterTableDataRowFilterPtrType) ToDataCellsFilterTableDataRowFilterPtrOutput() DataCellsFilterTableDataRowFilterPtrOutput {
	return i.ToDataCellsFilterTableDataRowFilterPtrOutputWithContext(context.Background())
}

func (i *dataCellsFilterTableDataRowFilterPtrType) ToDataCellsFilterTableDataRowFilterPtrOutputWithContext(ctx context.Context) DataCellsFilterTableDataRowFilterPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DataCellsFilterTableDataRowFilterPtrOutput)
}

type DataCellsFilterTableDataRowFilterOutput struct{ *pulumi.OutputState }

func (DataCellsFilterTableDataRowFilterOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*DataCellsFilterTableDataRowFilter)(nil)).Elem()
}

func (o DataCellsFilterTableDataRowFilterOutput) ToDataCellsFilterTableDataRowFilterOutput() DataCellsFilterTableDataRowFilterOutput {
	return o
}

func (o DataCellsFilterTableDataRowFilterOutput) ToDataCellsFilterTableDataRowFilterOutputWithContext(ctx context.Context) DataCellsFilterTableDataRowFilterOutput {
	return o
}

func (o DataCellsFilterTableDataRowFilterOutput) ToDataCellsFilterTableDataRowFilterPtrOutput() DataCellsFilterTableDataRowFilterPtrOutput {
	return o.ToDataCellsFilterTableDataRowFilterPtrOutputWithContext(context.Background())
}

func (o DataCellsFilterTableDataRowFilterOutput) ToDataCellsFilterTableDataRowFilterPtrOutputWithContext(ctx context.Context) DataCellsFilterTableDataRowFilterPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v DataCellsFilterTableDataRowFilter) *DataCellsFilterTableDataRowFilter {
		return &v
	}).(DataCellsFilterTableDataRowFilterPtrOutput)
}

// (Optional) A wildcard that matches all rows.
func (o DataCellsFilterTableDataRowFilterOutput) AllRowsWildcard() DataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput {
	return o.ApplyT(func(v DataCellsFilterTableDataRowFilter) *DataCellsFilterTableDataRowFilterAllRowsWildcard {
		return v.AllRowsWildcard
	}).(DataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput)
}

// (Optional) A filter expression.
func (o DataCellsFilterTableDataRowFilterOutput) FilterExpression() pulumi.StringPtrOutput {
	return o.ApplyT(func(v DataCellsFilterTableDataRowFilter) *string { return v.FilterExpression }).(pulumi.StringPtrOutput)
}

type DataCellsFilterTableDataRowFilterPtrOutput struct{ *pulumi.OutputState }

func (DataCellsFilterTableDataRowFilterPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**DataCellsFilterTableDataRowFilter)(nil)).Elem()
}

func (o DataCellsFilterTableDataRowFilterPtrOutput) ToDataCellsFilterTableDataRowFilterPtrOutput() DataCellsFilterTableDataRowFilterPtrOutput {
	return o
}

func (o DataCellsFilterTableDataRowFilterPtrOutput) ToDataCellsFilterTableDataRowFilterPtrOutputWithContext(ctx context.Context) DataCellsFilterTableDataRowFilterPtrOutput {
	return o
}

func (o DataCellsFilterTableDataRowFilterPtrOutput) Elem() DataCellsFilterTableDataRowFilterOutput {
	return o.ApplyT(func(v *DataCellsFilterTableDataRowFilter) DataCellsFilterTableDataRowFilter {
		if v != nil {
			return *v
		}
		var ret DataCellsFilterTableDataRowFilter
		return ret
	}).(DataCellsFilterTableDataRowFilterOutput)
}

// (Optional) A wildcard that matches all rows.
func (o DataCellsFilterTableDataRowFilterPtrOutput) AllRowsWildcard() DataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput {
	return o.ApplyT(func(v *DataCellsFilterTableDataRowFilter) *DataCellsFilterTableDataRowFilterAllRowsWildcard {
		if v == nil {
			return nil
		}
		return v.AllRowsWildcard
	}).(DataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput)
}

// (Optional) A filter expression.
func (o DataCellsFilterTableDataRowFilterPtrOutput) FilterExpression() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DataCellsFilterTableDataRowFilter) *string {
		if v == nil {
			return nil
		}
		return v.FilterExpression
	}).(pulumi.StringPtrOutput)
}

type DataCellsFilterTableDataRowFilterAllRowsWildcard struct {
}

// DataCellsFilterTableDataRowFilterAllRowsWildcardInput is an input type that accepts DataCellsFilterTableDataRowFilterAllRowsWildcardArgs and DataCellsFilterTableDataRowFilterAllRowsWildcardOutput values.
// You can construct a concrete instance of `DataCellsFilterTableDataRowFilterAllRowsWildcardInput` via:
//
//	DataCellsFilterTableDataRowFilterAllRowsWildcardArgs{...}
type DataCellsFilterTableDataRowFilterAllRowsWildcardInput interface {
	pulumi.Input

	ToDataCellsFilterTableDataRowFilterAllRowsWildcardOutput() DataCellsFilterTableDataRowFilterAllRowsWildcardOutput
	ToDataCellsFilterTableDataRowFilterAllRowsWildcardOutputWithContext(context.Context) DataCellsFilterTableDataRowFilterAllRowsWildcardOutput
}

type DataCellsFilterTableDataRowFilterAllRowsWildcardArgs struct {
}

func (DataCellsFilterTableDataRowFilterAllRowsWildcardArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*DataCellsFilterTableDataRowFilterAllRowsWildcard)(nil)).Elem()
}

func (i DataCellsFilterTableDataRowFilterAllRowsWildcardArgs) ToDataCellsFilterTableDataRowFilterAllRowsWildcardOutput() DataCellsFilterTableDataRowFilterAllRowsWildcardOutput {
	return i.ToDataCellsFilterTableDataRowFilterAllRowsWildcardOutputWithContext(context.Background())
}

func (i DataCellsFilterTableDataRowFilterAllRowsWildcardArgs) ToDataCellsFilterTableDataRowFilterAllRowsWildcardOutputWithContext(ctx context.Context) DataCellsFilterTableDataRowFilterAllRowsWildcardOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DataCellsFilterTableDataRowFilterAllRowsWildcardOutput)
}

func (i DataCellsFilterTableDataRowFilterAllRowsWildcardArgs) ToDataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput() DataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput {
	return i.ToDataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutputWithContext(context.Background())
}

func (i DataCellsFilterTableDataRowFilterAllRowsWildcardArgs) ToDataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutputWithContext(ctx context.Context) DataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DataCellsFilterTableDataRowFilterAllRowsWildcardOutput).ToDataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutputWithContext(ctx)
}

// DataCellsFilterTableDataRowFilterAllRowsWildcardPtrInput is an input type that accepts DataCellsFilterTableDataRowFilterAllRowsWildcardArgs, DataCellsFilterTableDataRowFilterAllRowsWildcardPtr and DataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput values.
// You can construct a concrete instance of `DataCellsFilterTableDataRowFilterAllRowsWildcardPtrInput` via:
//
//	        DataCellsFilterTableDataRowFilterAllRowsWildcardArgs{...}
//
//	or:
//
//	        nil
type DataCellsFilterTableDataRowFilterAllRowsWildcardPtrInput interface {
	pulumi.Input

	ToDataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput() DataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput
	ToDataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutputWithContext(context.Context) DataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput
}

type dataCellsFilterTableDataRowFilterAllRowsWildcardPtrType DataCellsFilterTableDataRowFilterAllRowsWildcardArgs

func DataCellsFilterTableDataRowFilterAllRowsWildcardPtr(v *DataCellsFilterTableDataRowFilterAllRowsWildcardArgs) DataCellsFilterTableDataRowFilterAllRowsWildcardPtrInput {
	return (*dataCellsFilterTableDataRowFilterAllRowsWildcardPtrType)(v)
}

func (*dataCellsFilterTableDataRowFilterAllRowsWildcardPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**DataCellsFilterTableDataRowFilterAllRowsWildcard)(nil)).Elem()
}

func (i *dataCellsFilterTableDataRowFilterAllRowsWildcardPtrType) ToDataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput() DataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput {
	return i.ToDataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutputWithContext(context.Background())
}

func (i *dataCellsFilterTableDataRowFilterAllRowsWildcardPtrType) ToDataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutputWithContext(ctx context.Context) DataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput)
}

type DataCellsFilterTableDataRowFilterAllRowsWildcardOutput struct{ *pulumi.OutputState }

func (DataCellsFilterTableDataRowFilterAllRowsWildcardOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*DataCellsFilterTableDataRowFilterAllRowsWildcard)(nil)).Elem()
}

func (o DataCellsFilterTableDataRowFilterAllRowsWildcardOutput) ToDataCellsFilterTableDataRowFilterAllRowsWildcardOutput() DataCellsFilterTableDataRowFilterAllRowsWildcardOutput {
	return o
}

func (o DataCellsFilterTableDataRowFilterAllRowsWildcardOutput) ToDataCellsFilterTableDataRowFilterAllRowsWildcardOutputWithContext(ctx context.Context) DataCellsFilterTableDataRowFilterAllRowsWildcardOutput {
	return o
}

func (o DataCellsFilterTableDataRowFilterAllRowsWildcardOutput) ToDataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput() DataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput {
	return o.ToDataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutputWithContext(context.Background())
}

func (o DataCellsFilterTableDataRowFilterAllRowsWildcardOutput) ToDataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutputWithContext(ctx context.Context) DataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v DataCellsFilterTableDataRowFilterAllRowsWildcard) *DataCellsFilterTableDataRowFilterAllRowsWildcard {
		return &v
	}).(DataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput)
}

type DataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput struct{ *pulumi.OutputState }

func (DataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**DataCellsFilterTableDataRowFilterAllRowsWildcard)(nil)).Elem()
}

func (o DataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput) ToDataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput() DataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput {
	return o
}

func (o DataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput) ToDataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutputWithContext(ctx context.Context) DataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput {
	return o
}

func (o DataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput) Elem() DataCellsFilterTableDataRowFilterAllRowsWildcardOutput {
	return o.ApplyT(func(v *DataCellsFilterTableDataRowFilterAllRowsWildcard) DataCellsFilterTableDataRowFilterAllRowsWildcard {
		if v != nil {
			return *v
		}
		var ret DataCellsFilterTableDataRowFilterAllRowsWildcard
		return ret
	}).(DataCellsFilterTableDataRowFilterAllRowsWildcardOutput)
}

type DataCellsFilterTimeouts struct {
	// A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
	Create *string `pulumi:"create"`
}

// DataCellsFilterTimeoutsInput is an input type that accepts DataCellsFilterTimeoutsArgs and DataCellsFilterTimeoutsOutput values.
// You can construct a concrete instance of `DataCellsFilterTimeoutsInput` via:
//
//	DataCellsFilterTimeoutsArgs{...}
type DataCellsFilterTimeoutsInput interface {
	pulumi.Input

	ToDataCellsFilterTimeoutsOutput() DataCellsFilterTimeoutsOutput
	ToDataCellsFilterTimeoutsOutputWithContext(context.Context) DataCellsFilterTimeoutsOutput
}

type DataCellsFilterTimeoutsArgs struct {
	// A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
	Create pulumi.StringPtrInput `pulumi:"create"`
}

func (DataCellsFilterTimeoutsArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*DataCellsFilterTimeouts)(nil)).Elem()
}

func (i DataCellsFilterTimeoutsArgs) ToDataCellsFilterTimeoutsOutput() DataCellsFilterTimeoutsOutput {
	return i.ToDataCellsFilterTimeoutsOutputWithContext(context.Background())
}

func (i DataCellsFilterTimeoutsArgs) ToDataCellsFilterTimeoutsOutputWithContext(ctx context.Context) DataCellsFilterTimeoutsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DataCellsFilterTimeoutsOutput)
}

func (i DataCellsFilterTimeoutsArgs) ToDataCellsFilterTimeoutsPtrOutput() DataCellsFilterTimeoutsPtrOutput {
	return i.ToDataCellsFilterTimeoutsPtrOutputWithContext(context.Background())
}

func (i DataCellsFilterTimeoutsArgs) ToDataCellsFilterTimeoutsPtrOutputWithContext(ctx context.Context) DataCellsFilterTimeoutsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DataCellsFilterTimeoutsOutput).ToDataCellsFilterTimeoutsPtrOutputWithContext(ctx)
}

// DataCellsFilterTimeoutsPtrInput is an input type that accepts DataCellsFilterTimeoutsArgs, DataCellsFilterTimeoutsPtr and DataCellsFilterTimeoutsPtrOutput values.
// You can construct a concrete instance of `DataCellsFilterTimeoutsPtrInput` via:
//
//	        DataCellsFilterTimeoutsArgs{...}
//
//	or:
//
//	        nil
type DataCellsFilterTimeoutsPtrInput interface {
	pulumi.Input

	ToDataCellsFilterTimeoutsPtrOutput() DataCellsFilterTimeoutsPtrOutput
	ToDataCellsFilterTimeoutsPtrOutputWithContext(context.Context) DataCellsFilterTimeoutsPtrOutput
}

type dataCellsFilterTimeoutsPtrType DataCellsFilterTimeoutsArgs

func DataCellsFilterTimeoutsPtr(v *DataCellsFilterTimeoutsArgs) DataCellsFilterTimeoutsPtrInput {
	return (*dataCellsFilterTimeoutsPtrType)(v)
}

func (*dataCellsFilterTimeoutsPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**DataCellsFilterTimeouts)(nil)).Elem()
}

func (i *dataCellsFilterTimeoutsPtrType) ToDataCellsFilterTimeoutsPtrOutput() DataCellsFilterTimeoutsPtrOutput {
	return i.ToDataCellsFilterTimeoutsPtrOutputWithContext(context.Background())
}

func (i *dataCellsFilterTimeoutsPtrType) ToDataCellsFilterTimeoutsPtrOutputWithContext(ctx context.Context) DataCellsFilterTimeoutsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DataCellsFilterTimeoutsPtrOutput)
}

type DataCellsFilterTimeoutsOutput struct{ *pulumi.OutputState }

func (DataCellsFilterTimeoutsOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*DataCellsFilterTimeouts)(nil)).Elem()
}

func (o DataCellsFilterTimeoutsOutput) ToDataCellsFilterTimeoutsOutput() DataCellsFilterTimeoutsOutput {
	return o
}

func (o DataCellsFilterTimeoutsOutput) ToDataCellsFilterTimeoutsOutputWithContext(ctx context.Context) DataCellsFilterTimeoutsOutput {
	return o
}

func (o DataCellsFilterTimeoutsOutput) ToDataCellsFilterTimeoutsPtrOutput() DataCellsFilterTimeoutsPtrOutput {
	return o.ToDataCellsFilterTimeoutsPtrOutputWithContext(context.Background())
}

func (o DataCellsFilterTimeoutsOutput) ToDataCellsFilterTimeoutsPtrOutputWithContext(ctx context.Context) DataCellsFilterTimeoutsPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v DataCellsFilterTimeouts) *DataCellsFilterTimeouts {
		return &v
	}).(DataCellsFilterTimeoutsPtrOutput)
}

// A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
func (o DataCellsFilterTimeoutsOutput) Create() pulumi.StringPtrOutput {
	return o.ApplyT(func(v DataCellsFilterTimeouts) *string { return v.Create }).(pulumi.StringPtrOutput)
}

type DataCellsFilterTimeoutsPtrOutput struct{ *pulumi.OutputState }

func (DataCellsFilterTimeoutsPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**DataCellsFilterTimeouts)(nil)).Elem()
}

func (o DataCellsFilterTimeoutsPtrOutput) ToDataCellsFilterTimeoutsPtrOutput() DataCellsFilterTimeoutsPtrOutput {
	return o
}

func (o DataCellsFilterTimeoutsPtrOutput) ToDataCellsFilterTimeoutsPtrOutputWithContext(ctx context.Context) DataCellsFilterTimeoutsPtrOutput {
	return o
}

func (o DataCellsFilterTimeoutsPtrOutput) Elem() DataCellsFilterTimeoutsOutput {
	return o.ApplyT(func(v *DataCellsFilterTimeouts) DataCellsFilterTimeouts {
		if v != nil {
			return *v
		}
		var ret DataCellsFilterTimeouts
		return ret
	}).(DataCellsFilterTimeoutsOutput)
}

// A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
func (o DataCellsFilterTimeoutsPtrOutput) Create() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *DataCellsFilterTimeouts) *string {
		if v == nil {
			return nil
		}
		return v.Create
	}).(pulumi.StringPtrOutput)
}

type DataLakeSettingsCreateDatabaseDefaultPermission struct {
	// List of permissions that are granted to the principal. Valid values may include `ALL`, `SELECT`, `ALTER`, `DROP`, `DELETE`, `INSERT`, `DESCRIBE`, and `CREATE_TABLE`. For more details, see [Lake Formation Permissions Reference](https://docs.aws.amazon.com/lake-formation/latest/dg/lf-permissions-reference.html).
	Permissions []string `pulumi:"permissions"`
	// Principal who is granted permissions. To enforce metadata and underlying data access control only by IAM on new databases and tables set `principal` to `IAM_ALLOWED_PRINCIPALS` and `permissions` to `["ALL"]`.
	Principal *string `pulumi:"principal"`
}

// DataLakeSettingsCreateDatabaseDefaultPermissionInput is an input type that accepts DataLakeSettingsCreateDatabaseDefaultPermissionArgs and DataLakeSettingsCreateDatabaseDefaultPermissionOutput values.
// You can construct a concrete instance of `DataLakeSettingsCreateDatabaseDefaultPermissionInput` via:
//
//	DataLakeSettingsCreateDatabaseDefaultPermissionArgs{...}
type DataLakeSettingsCreateDatabaseDefaultPermissionInput interface {
	pulumi.Input

	ToDataLakeSettingsCreateDatabaseDefaultPermissionOutput() DataLakeSettingsCreateDatabaseDefaultPermissionOutput
	ToDataLakeSettingsCreateDatabaseDefaultPermissionOutputWithContext(context.Context) DataLakeSettingsCreateDatabaseDefaultPermissionOutput
}

type DataLakeSettingsCreateDatabaseDefaultPermissionArgs struct {
	// List of permissions that are granted to the principal. Valid values may include `ALL`, `SELECT`, `ALTER`, `DROP`, `DELETE`, `INSERT`, `DESCRIBE`, and `CREATE_TABLE`. For more details, see [Lake Formation Permissions Reference](https://docs.aws.amazon.com/lake-formation/latest/dg/lf-permissions-reference.html).
	Permissions pulumi.StringArrayInput `pulumi:"permissions"`
	// Principal who is granted permissions. To enforce metadata and underlying data access control only by IAM on new databases and tables set `principal` to `IAM_ALLOWED_PRINCIPALS` and `permissions` to `["ALL"]`.
	Principal pulumi.StringPtrInput `pulumi:"principal"`
}

func (DataLakeSettingsCreateDatabaseDefaultPermissionArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*DataLakeSettingsCreateDatabaseDefaultPermission)(nil)).Elem()
}

func (i DataLakeSettingsCreateDatabaseDefaultPermissionArgs) ToDataLakeSettingsCreateDatabaseDefaultPermissionOutput() DataLakeSettingsCreateDatabaseDefaultPermissionOutput {
	return i.ToDataLakeSettingsCreateDatabaseDefaultPermissionOutputWithContext(context.Background())
}

func (i DataLakeSettingsCreateDatabaseDefaultPermissionArgs) ToDataLakeSettingsCreateDatabaseDefaultPermissionOutputWithContext(ctx context.Context) DataLakeSettingsCreateDatabaseDefaultPermissionOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DataLakeSettingsCreateDatabaseDefaultPermissionOutput)
}

// DataLakeSettingsCreateDatabaseDefaultPermissionArrayInput is an input type that accepts DataLakeSettingsCreateDatabaseDefaultPermissionArray and DataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput values.
// You can construct a concrete instance of `DataLakeSettingsCreateDatabaseDefaultPermissionArrayInput` via:
//
//	DataLakeSettingsCreateDatabaseDefaultPermissionArray{ DataLakeSettingsCreateDatabaseDefaultPermissionArgs{...} }
type DataLakeSettingsCreateDatabaseDefaultPermissionArrayInput interface {
	pulumi.Input

	ToDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput() DataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput
	ToDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutputWithContext(context.Context) DataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput
}

type DataLakeSettingsCreateDatabaseDefaultPermissionArray []DataLakeSettingsCreateDatabaseDefaultPermissionInput

func (DataLakeSettingsCreateDatabaseDefaultPermissionArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]DataLakeSettingsCreateDatabaseDefaultPermission)(nil)).Elem()
}

func (i DataLakeSettingsCreateDatabaseDefaultPermissionArray) ToDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput() DataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput {
	return i.ToDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutputWithContext(context.Background())
}

func (i DataLakeSettingsCreateDatabaseDefaultPermissionArray) ToDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutputWithContext(ctx context.Context) DataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput)
}

type DataLakeSettingsCreateDatabaseDefaultPermissionOutput struct{ *pulumi.OutputState }

func (DataLakeSettingsCreateDatabaseDefaultPermissionOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*DataLakeSettingsCreateDatabaseDefaultPermission)(nil)).Elem()
}

func (o DataLakeSettingsCreateDatabaseDefaultPermissionOutput) ToDataLakeSettingsCreateDatabaseDefaultPermissionOutput() DataLakeSettingsCreateDatabaseDefaultPermissionOutput {
	return o
}

func (o DataLakeSettingsCreateDatabaseDefaultPermissionOutput) ToDataLakeSettingsCreateDatabaseDefaultPermissionOutputWithContext(ctx context.Context) DataLakeSettingsCreateDatabaseDefaultPermissionOutput {
	return o
}

// List of permissions that are granted to the principal. Valid values may include `ALL`, `SELECT`, `ALTER`, `DROP`, `DELETE`, `INSERT`, `DESCRIBE`, and `CREATE_TABLE`. For more details, see [Lake Formation Permissions Reference](https://docs.aws.amazon.com/lake-formation/latest/dg/lf-permissions-reference.html).
func (o DataLakeSettingsCreateDatabaseDefaultPermissionOutput) Permissions() pulumi.StringArrayOutput {
	return o.ApplyT(func(v DataLakeSettingsCreateDatabaseDefaultPermission) []string { return v.Permissions }).(pulumi.StringArrayOutput)
}

// Principal who is granted permissions. To enforce metadata and underlying data access control only by IAM on new databases and tables set `principal` to `IAM_ALLOWED_PRINCIPALS` and `permissions` to `["ALL"]`.
func (o DataLakeSettingsCreateDatabaseDefaultPermissionOutput) Principal() pulumi.StringPtrOutput {
	return o.ApplyT(func(v DataLakeSettingsCreateDatabaseDefaultPermission) *string { return v.Principal }).(pulumi.StringPtrOutput)
}

type DataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput struct{ *pulumi.OutputState }

func (DataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]DataLakeSettingsCreateDatabaseDefaultPermission)(nil)).Elem()
}

func (o DataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput) ToDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput() DataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput {
	return o
}

func (o DataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput) ToDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutputWithContext(ctx context.Context) DataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput {
	return o
}

func (o DataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput) Index(i pulumi.IntInput) DataLakeSettingsCreateDatabaseDefaultPermissionOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) DataLakeSettingsCreateDatabaseDefaultPermission {
		return vs[0].([]DataLakeSettingsCreateDatabaseDefaultPermission)[vs[1].(int)]
	}).(DataLakeSettingsCreateDatabaseDefaultPermissionOutput)
}

type DataLakeSettingsCreateTableDefaultPermission struct {
	// List of permissions that are granted to the principal. Valid values may include `ALL`, `SELECT`, `ALTER`, `DROP`, `DELETE`, `INSERT`, and `DESCRIBE`. For more details, see [Lake Formation Permissions Reference](https://docs.aws.amazon.com/lake-formation/latest/dg/lf-permissions-reference.html).
	Permissions []string `pulumi:"permissions"`
	// Principal who is granted permissions. To enforce metadata and underlying data access control only by IAM on new databases and tables set `principal` to `IAM_ALLOWED_PRINCIPALS` and `permissions` to `["ALL"]`.
	Principal *string `pulumi:"principal"`
}

// DataLakeSettingsCreateTableDefaultPermissionInput is an input type that accepts DataLakeSettingsCreateTableDefaultPermissionArgs and DataLakeSettingsCreateTableDefaultPermissionOutput values.
// You can construct a concrete instance of `DataLakeSettingsCreateTableDefaultPermissionInput` via:
//
//	DataLakeSettingsCreateTableDefaultPermissionArgs{...}
type DataLakeSettingsCreateTableDefaultPermissionInput interface {
	pulumi.Input

	ToDataLakeSettingsCreateTableDefaultPermissionOutput() DataLakeSettingsCreateTableDefaultPermissionOutput
	ToDataLakeSettingsCreateTableDefaultPermissionOutputWithContext(context.Context) DataLakeSettingsCreateTableDefaultPermissionOutput
}

type DataLakeSettingsCreateTableDefaultPermissionArgs struct {
	// List of permissions that are granted to the principal. Valid values may include `ALL`, `SELECT`, `ALTER`, `DROP`, `DELETE`, `INSERT`, and `DESCRIBE`. For more details, see [Lake Formation Permissions Reference](https://docs.aws.amazon.com/lake-formation/latest/dg/lf-permissions-reference.html).
	Permissions pulumi.StringArrayInput `pulumi:"permissions"`
	// Principal who is granted permissions. To enforce metadata and underlying data access control only by IAM on new databases and tables set `principal` to `IAM_ALLOWED_PRINCIPALS` and `permissions` to `["ALL"]`.
	Principal pulumi.StringPtrInput `pulumi:"principal"`
}

func (DataLakeSettingsCreateTableDefaultPermissionArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*DataLakeSettingsCreateTableDefaultPermission)(nil)).Elem()
}

func (i DataLakeSettingsCreateTableDefaultPermissionArgs) ToDataLakeSettingsCreateTableDefaultPermissionOutput() DataLakeSettingsCreateTableDefaultPermissionOutput {
	return i.ToDataLakeSettingsCreateTableDefaultPermissionOutputWithContext(context.Background())
}

func (i DataLakeSettingsCreateTableDefaultPermissionArgs) ToDataLakeSettingsCreateTableDefaultPermissionOutputWithContext(ctx context.Context) DataLakeSettingsCreateTableDefaultPermissionOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DataLakeSettingsCreateTableDefaultPermissionOutput)
}

// DataLakeSettingsCreateTableDefaultPermissionArrayInput is an input type that accepts DataLakeSettingsCreateTableDefaultPermissionArray and DataLakeSettingsCreateTableDefaultPermissionArrayOutput values.
// You can construct a concrete instance of `DataLakeSettingsCreateTableDefaultPermissionArrayInput` via:
//
//	DataLakeSettingsCreateTableDefaultPermissionArray{ DataLakeSettingsCreateTableDefaultPermissionArgs{...} }
type DataLakeSettingsCreateTableDefaultPermissionArrayInput interface {
	pulumi.Input

	ToDataLakeSettingsCreateTableDefaultPermissionArrayOutput() DataLakeSettingsCreateTableDefaultPermissionArrayOutput
	ToDataLakeSettingsCreateTableDefaultPermissionArrayOutputWithContext(context.Context) DataLakeSettingsCreateTableDefaultPermissionArrayOutput
}

type DataLakeSettingsCreateTableDefaultPermissionArray []DataLakeSettingsCreateTableDefaultPermissionInput

func (DataLakeSettingsCreateTableDefaultPermissionArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]DataLakeSettingsCreateTableDefaultPermission)(nil)).Elem()
}

func (i DataLakeSettingsCreateTableDefaultPermissionArray) ToDataLakeSettingsCreateTableDefaultPermissionArrayOutput() DataLakeSettingsCreateTableDefaultPermissionArrayOutput {
	return i.ToDataLakeSettingsCreateTableDefaultPermissionArrayOutputWithContext(context.Background())
}

func (i DataLakeSettingsCreateTableDefaultPermissionArray) ToDataLakeSettingsCreateTableDefaultPermissionArrayOutputWithContext(ctx context.Context) DataLakeSettingsCreateTableDefaultPermissionArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(DataLakeSettingsCreateTableDefaultPermissionArrayOutput)
}

type DataLakeSettingsCreateTableDefaultPermissionOutput struct{ *pulumi.OutputState }

func (DataLakeSettingsCreateTableDefaultPermissionOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*DataLakeSettingsCreateTableDefaultPermission)(nil)).Elem()
}

func (o DataLakeSettingsCreateTableDefaultPermissionOutput) ToDataLakeSettingsCreateTableDefaultPermissionOutput() DataLakeSettingsCreateTableDefaultPermissionOutput {
	return o
}

func (o DataLakeSettingsCreateTableDefaultPermissionOutput) ToDataLakeSettingsCreateTableDefaultPermissionOutputWithContext(ctx context.Context) DataLakeSettingsCreateTableDefaultPermissionOutput {
	return o
}

// List of permissions that are granted to the principal. Valid values may include `ALL`, `SELECT`, `ALTER`, `DROP`, `DELETE`, `INSERT`, and `DESCRIBE`. For more details, see [Lake Formation Permissions Reference](https://docs.aws.amazon.com/lake-formation/latest/dg/lf-permissions-reference.html).
func (o DataLakeSettingsCreateTableDefaultPermissionOutput) Permissions() pulumi.StringArrayOutput {
	return o.ApplyT(func(v DataLakeSettingsCreateTableDefaultPermission) []string { return v.Permissions }).(pulumi.StringArrayOutput)
}

// Principal who is granted permissions. To enforce metadata and underlying data access control only by IAM on new databases and tables set `principal` to `IAM_ALLOWED_PRINCIPALS` and `permissions` to `["ALL"]`.
func (o DataLakeSettingsCreateTableDefaultPermissionOutput) Principal() pulumi.StringPtrOutput {
	return o.ApplyT(func(v DataLakeSettingsCreateTableDefaultPermission) *string { return v.Principal }).(pulumi.StringPtrOutput)
}

type DataLakeSettingsCreateTableDefaultPermissionArrayOutput struct{ *pulumi.OutputState }

func (DataLakeSettingsCreateTableDefaultPermissionArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]DataLakeSettingsCreateTableDefaultPermission)(nil)).Elem()
}

func (o DataLakeSettingsCreateTableDefaultPermissionArrayOutput) ToDataLakeSettingsCreateTableDefaultPermissionArrayOutput() DataLakeSettingsCreateTableDefaultPermissionArrayOutput {
	return o
}

func (o DataLakeSettingsCreateTableDefaultPermissionArrayOutput) ToDataLakeSettingsCreateTableDefaultPermissionArrayOutputWithContext(ctx context.Context) DataLakeSettingsCreateTableDefaultPermissionArrayOutput {
	return o
}

func (o DataLakeSettingsCreateTableDefaultPermissionArrayOutput) Index(i pulumi.IntInput) DataLakeSettingsCreateTableDefaultPermissionOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) DataLakeSettingsCreateTableDefaultPermission {
		return vs[0].([]DataLakeSettingsCreateTableDefaultPermission)[vs[1].(int)]
	}).(DataLakeSettingsCreateTableDefaultPermissionOutput)
}

type PermissionsDataCellsFilter struct {
	// The name of the database.
	DatabaseName string `pulumi:"databaseName"`
	// The name of the data cells filter.
	Name string `pulumi:"name"`
	// The ID of the Data Catalog.
	TableCatalogId string `pulumi:"tableCatalogId"`
	// The name of the table.
	TableName string `pulumi:"tableName"`
}

// PermissionsDataCellsFilterInput is an input type that accepts PermissionsDataCellsFilterArgs and PermissionsDataCellsFilterOutput values.
// You can construct a concrete instance of `PermissionsDataCellsFilterInput` via:
//
//	PermissionsDataCellsFilterArgs{...}
type PermissionsDataCellsFilterInput interface {
	pulumi.Input

	ToPermissionsDataCellsFilterOutput() PermissionsDataCellsFilterOutput
	ToPermissionsDataCellsFilterOutputWithContext(context.Context) PermissionsDataCellsFilterOutput
}

type PermissionsDataCellsFilterArgs struct {
	// The name of the database.
	DatabaseName pulumi.StringInput `pulumi:"databaseName"`
	// The name of the data cells filter.
	Name pulumi.StringInput `pulumi:"name"`
	// The ID of the Data Catalog.
	TableCatalogId pulumi.StringInput `pulumi:"tableCatalogId"`
	// The name of the table.
	TableName pulumi.StringInput `pulumi:"tableName"`
}

func (PermissionsDataCellsFilterArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*PermissionsDataCellsFilter)(nil)).Elem()
}

func (i PermissionsDataCellsFilterArgs) ToPermissionsDataCellsFilterOutput() PermissionsDataCellsFilterOutput {
	return i.ToPermissionsDataCellsFilterOutputWithContext(context.Background())
}

func (i PermissionsDataCellsFilterArgs) ToPermissionsDataCellsFilterOutputWithContext(ctx context.Context) PermissionsDataCellsFilterOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PermissionsDataCellsFilterOutput)
}

func (i PermissionsDataCellsFilterArgs) ToPermissionsDataCellsFilterPtrOutput() PermissionsDataCellsFilterPtrOutput {
	return i.ToPermissionsDataCellsFilterPtrOutputWithContext(context.Background())
}

func (i PermissionsDataCellsFilterArgs) ToPermissionsDataCellsFilterPtrOutputWithContext(ctx context.Context) PermissionsDataCellsFilterPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PermissionsDataCellsFilterOutput).ToPermissionsDataCellsFilterPtrOutputWithContext(ctx)
}

// PermissionsDataCellsFilterPtrInput is an input type that accepts PermissionsDataCellsFilterArgs, PermissionsDataCellsFilterPtr and PermissionsDataCellsFilterPtrOutput values.
// You can construct a concrete instance of `PermissionsDataCellsFilterPtrInput` via:
//
//	        PermissionsDataCellsFilterArgs{...}
//
//	or:
//
//	        nil
type PermissionsDataCellsFilterPtrInput interface {
	pulumi.Input

	ToPermissionsDataCellsFilterPtrOutput() PermissionsDataCellsFilterPtrOutput
	ToPermissionsDataCellsFilterPtrOutputWithContext(context.Context) PermissionsDataCellsFilterPtrOutput
}

type permissionsDataCellsFilterPtrType PermissionsDataCellsFilterArgs

func PermissionsDataCellsFilterPtr(v *PermissionsDataCellsFilterArgs) PermissionsDataCellsFilterPtrInput {
	return (*permissionsDataCellsFilterPtrType)(v)
}

func (*permissionsDataCellsFilterPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**PermissionsDataCellsFilter)(nil)).Elem()
}

func (i *permissionsDataCellsFilterPtrType) ToPermissionsDataCellsFilterPtrOutput() PermissionsDataCellsFilterPtrOutput {
	return i.ToPermissionsDataCellsFilterPtrOutputWithContext(context.Background())
}

func (i *permissionsDataCellsFilterPtrType) ToPermissionsDataCellsFilterPtrOutputWithContext(ctx context.Context) PermissionsDataCellsFilterPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PermissionsDataCellsFilterPtrOutput)
}

type PermissionsDataCellsFilterOutput struct{ *pulumi.OutputState }

func (PermissionsDataCellsFilterOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PermissionsDataCellsFilter)(nil)).Elem()
}

func (o PermissionsDataCellsFilterOutput) ToPermissionsDataCellsFilterOutput() PermissionsDataCellsFilterOutput {
	return o
}

func (o PermissionsDataCellsFilterOutput) ToPermissionsDataCellsFilterOutputWithContext(ctx context.Context) PermissionsDataCellsFilterOutput {
	return o
}

func (o PermissionsDataCellsFilterOutput) ToPermissionsDataCellsFilterPtrOutput() PermissionsDataCellsFilterPtrOutput {
	return o.ToPermissionsDataCellsFilterPtrOutputWithContext(context.Background())
}

func (o PermissionsDataCellsFilterOutput) ToPermissionsDataCellsFilterPtrOutputWithContext(ctx context.Context) PermissionsDataCellsFilterPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v PermissionsDataCellsFilter) *PermissionsDataCellsFilter {
		return &v
	}).(PermissionsDataCellsFilterPtrOutput)
}

// The name of the database.
func (o PermissionsDataCellsFilterOutput) DatabaseName() pulumi.StringOutput {
	return o.ApplyT(func(v PermissionsDataCellsFilter) string { return v.DatabaseName }).(pulumi.StringOutput)
}

// The name of the data cells filter.
func (o PermissionsDataCellsFilterOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v PermissionsDataCellsFilter) string { return v.Name }).(pulumi.StringOutput)
}

// The ID of the Data Catalog.
func (o PermissionsDataCellsFilterOutput) TableCatalogId() pulumi.StringOutput {
	return o.ApplyT(func(v PermissionsDataCellsFilter) string { return v.TableCatalogId }).(pulumi.StringOutput)
}

// The name of the table.
func (o PermissionsDataCellsFilterOutput) TableName() pulumi.StringOutput {
	return o.ApplyT(func(v PermissionsDataCellsFilter) string { return v.TableName }).(pulumi.StringOutput)
}

type PermissionsDataCellsFilterPtrOutput struct{ *pulumi.OutputState }

func (PermissionsDataCellsFilterPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**PermissionsDataCellsFilter)(nil)).Elem()
}

func (o PermissionsDataCellsFilterPtrOutput) ToPermissionsDataCellsFilterPtrOutput() PermissionsDataCellsFilterPtrOutput {
	return o
}

func (o PermissionsDataCellsFilterPtrOutput) ToPermissionsDataCellsFilterPtrOutputWithContext(ctx context.Context) PermissionsDataCellsFilterPtrOutput {
	return o
}

func (o PermissionsDataCellsFilterPtrOutput) Elem() PermissionsDataCellsFilterOutput {
	return o.ApplyT(func(v *PermissionsDataCellsFilter) PermissionsDataCellsFilter {
		if v != nil {
			return *v
		}
		var ret PermissionsDataCellsFilter
		return ret
	}).(PermissionsDataCellsFilterOutput)
}

// The name of the database.
func (o PermissionsDataCellsFilterPtrOutput) DatabaseName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PermissionsDataCellsFilter) *string {
		if v == nil {
			return nil
		}
		return &v.DatabaseName
	}).(pulumi.StringPtrOutput)
}

// The name of the data cells filter.
func (o PermissionsDataCellsFilterPtrOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PermissionsDataCellsFilter) *string {
		if v == nil {
			return nil
		}
		return &v.Name
	}).(pulumi.StringPtrOutput)
}

// The ID of the Data Catalog.
func (o PermissionsDataCellsFilterPtrOutput) TableCatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PermissionsDataCellsFilter) *string {
		if v == nil {
			return nil
		}
		return &v.TableCatalogId
	}).(pulumi.StringPtrOutput)
}

// The name of the table.
func (o PermissionsDataCellsFilterPtrOutput) TableName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PermissionsDataCellsFilter) *string {
		if v == nil {
			return nil
		}
		return &v.TableName
	}).(pulumi.StringPtrOutput)
}

type PermissionsDataLocation struct {
	// Amazon Resource Name (ARN) that uniquely identifies the data location resource.
	//
	// The following argument is optional:
	Arn string `pulumi:"arn"`
	// Identifier for the Data Catalog where the location is registered with Lake Formation. By default, it is the account ID of the caller.
	CatalogId *string `pulumi:"catalogId"`
}

// PermissionsDataLocationInput is an input type that accepts PermissionsDataLocationArgs and PermissionsDataLocationOutput values.
// You can construct a concrete instance of `PermissionsDataLocationInput` via:
//
//	PermissionsDataLocationArgs{...}
type PermissionsDataLocationInput interface {
	pulumi.Input

	ToPermissionsDataLocationOutput() PermissionsDataLocationOutput
	ToPermissionsDataLocationOutputWithContext(context.Context) PermissionsDataLocationOutput
}

type PermissionsDataLocationArgs struct {
	// Amazon Resource Name (ARN) that uniquely identifies the data location resource.
	//
	// The following argument is optional:
	Arn pulumi.StringInput `pulumi:"arn"`
	// Identifier for the Data Catalog where the location is registered with Lake Formation. By default, it is the account ID of the caller.
	CatalogId pulumi.StringPtrInput `pulumi:"catalogId"`
}

func (PermissionsDataLocationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*PermissionsDataLocation)(nil)).Elem()
}

func (i PermissionsDataLocationArgs) ToPermissionsDataLocationOutput() PermissionsDataLocationOutput {
	return i.ToPermissionsDataLocationOutputWithContext(context.Background())
}

func (i PermissionsDataLocationArgs) ToPermissionsDataLocationOutputWithContext(ctx context.Context) PermissionsDataLocationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PermissionsDataLocationOutput)
}

func (i PermissionsDataLocationArgs) ToPermissionsDataLocationPtrOutput() PermissionsDataLocationPtrOutput {
	return i.ToPermissionsDataLocationPtrOutputWithContext(context.Background())
}

func (i PermissionsDataLocationArgs) ToPermissionsDataLocationPtrOutputWithContext(ctx context.Context) PermissionsDataLocationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PermissionsDataLocationOutput).ToPermissionsDataLocationPtrOutputWithContext(ctx)
}

// PermissionsDataLocationPtrInput is an input type that accepts PermissionsDataLocationArgs, PermissionsDataLocationPtr and PermissionsDataLocationPtrOutput values.
// You can construct a concrete instance of `PermissionsDataLocationPtrInput` via:
//
//	        PermissionsDataLocationArgs{...}
//
//	or:
//
//	        nil
type PermissionsDataLocationPtrInput interface {
	pulumi.Input

	ToPermissionsDataLocationPtrOutput() PermissionsDataLocationPtrOutput
	ToPermissionsDataLocationPtrOutputWithContext(context.Context) PermissionsDataLocationPtrOutput
}

type permissionsDataLocationPtrType PermissionsDataLocationArgs

func PermissionsDataLocationPtr(v *PermissionsDataLocationArgs) PermissionsDataLocationPtrInput {
	return (*permissionsDataLocationPtrType)(v)
}

func (*permissionsDataLocationPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**PermissionsDataLocation)(nil)).Elem()
}

func (i *permissionsDataLocationPtrType) ToPermissionsDataLocationPtrOutput() PermissionsDataLocationPtrOutput {
	return i.ToPermissionsDataLocationPtrOutputWithContext(context.Background())
}

func (i *permissionsDataLocationPtrType) ToPermissionsDataLocationPtrOutputWithContext(ctx context.Context) PermissionsDataLocationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PermissionsDataLocationPtrOutput)
}

type PermissionsDataLocationOutput struct{ *pulumi.OutputState }

func (PermissionsDataLocationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PermissionsDataLocation)(nil)).Elem()
}

func (o PermissionsDataLocationOutput) ToPermissionsDataLocationOutput() PermissionsDataLocationOutput {
	return o
}

func (o PermissionsDataLocationOutput) ToPermissionsDataLocationOutputWithContext(ctx context.Context) PermissionsDataLocationOutput {
	return o
}

func (o PermissionsDataLocationOutput) ToPermissionsDataLocationPtrOutput() PermissionsDataLocationPtrOutput {
	return o.ToPermissionsDataLocationPtrOutputWithContext(context.Background())
}

func (o PermissionsDataLocationOutput) ToPermissionsDataLocationPtrOutputWithContext(ctx context.Context) PermissionsDataLocationPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v PermissionsDataLocation) *PermissionsDataLocation {
		return &v
	}).(PermissionsDataLocationPtrOutput)
}

// Amazon Resource Name (ARN) that uniquely identifies the data location resource.
//
// The following argument is optional:
func (o PermissionsDataLocationOutput) Arn() pulumi.StringOutput {
	return o.ApplyT(func(v PermissionsDataLocation) string { return v.Arn }).(pulumi.StringOutput)
}

// Identifier for the Data Catalog where the location is registered with Lake Formation. By default, it is the account ID of the caller.
func (o PermissionsDataLocationOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PermissionsDataLocation) *string { return v.CatalogId }).(pulumi.StringPtrOutput)
}

type PermissionsDataLocationPtrOutput struct{ *pulumi.OutputState }

func (PermissionsDataLocationPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**PermissionsDataLocation)(nil)).Elem()
}

func (o PermissionsDataLocationPtrOutput) ToPermissionsDataLocationPtrOutput() PermissionsDataLocationPtrOutput {
	return o
}

func (o PermissionsDataLocationPtrOutput) ToPermissionsDataLocationPtrOutputWithContext(ctx context.Context) PermissionsDataLocationPtrOutput {
	return o
}

func (o PermissionsDataLocationPtrOutput) Elem() PermissionsDataLocationOutput {
	return o.ApplyT(func(v *PermissionsDataLocation) PermissionsDataLocation {
		if v != nil {
			return *v
		}
		var ret PermissionsDataLocation
		return ret
	}).(PermissionsDataLocationOutput)
}

// Amazon Resource Name (ARN) that uniquely identifies the data location resource.
//
// The following argument is optional:
func (o PermissionsDataLocationPtrOutput) Arn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PermissionsDataLocation) *string {
		if v == nil {
			return nil
		}
		return &v.Arn
	}).(pulumi.StringPtrOutput)
}

// Identifier for the Data Catalog where the location is registered with Lake Formation. By default, it is the account ID of the caller.
func (o PermissionsDataLocationPtrOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PermissionsDataLocation) *string {
		if v == nil {
			return nil
		}
		return v.CatalogId
	}).(pulumi.StringPtrOutput)
}

type PermissionsDatabase struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId *string `pulumi:"catalogId"`
	// Name of the database resource. Unique to the Data Catalog.
	//
	// The following argument is optional:
	Name string `pulumi:"name"`
}

// PermissionsDatabaseInput is an input type that accepts PermissionsDatabaseArgs and PermissionsDatabaseOutput values.
// You can construct a concrete instance of `PermissionsDatabaseInput` via:
//
//	PermissionsDatabaseArgs{...}
type PermissionsDatabaseInput interface {
	pulumi.Input

	ToPermissionsDatabaseOutput() PermissionsDatabaseOutput
	ToPermissionsDatabaseOutputWithContext(context.Context) PermissionsDatabaseOutput
}

type PermissionsDatabaseArgs struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId pulumi.StringPtrInput `pulumi:"catalogId"`
	// Name of the database resource. Unique to the Data Catalog.
	//
	// The following argument is optional:
	Name pulumi.StringInput `pulumi:"name"`
}

func (PermissionsDatabaseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*PermissionsDatabase)(nil)).Elem()
}

func (i PermissionsDatabaseArgs) ToPermissionsDatabaseOutput() PermissionsDatabaseOutput {
	return i.ToPermissionsDatabaseOutputWithContext(context.Background())
}

func (i PermissionsDatabaseArgs) ToPermissionsDatabaseOutputWithContext(ctx context.Context) PermissionsDatabaseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PermissionsDatabaseOutput)
}

func (i PermissionsDatabaseArgs) ToPermissionsDatabasePtrOutput() PermissionsDatabasePtrOutput {
	return i.ToPermissionsDatabasePtrOutputWithContext(context.Background())
}

func (i PermissionsDatabaseArgs) ToPermissionsDatabasePtrOutputWithContext(ctx context.Context) PermissionsDatabasePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PermissionsDatabaseOutput).ToPermissionsDatabasePtrOutputWithContext(ctx)
}

// PermissionsDatabasePtrInput is an input type that accepts PermissionsDatabaseArgs, PermissionsDatabasePtr and PermissionsDatabasePtrOutput values.
// You can construct a concrete instance of `PermissionsDatabasePtrInput` via:
//
//	        PermissionsDatabaseArgs{...}
//
//	or:
//
//	        nil
type PermissionsDatabasePtrInput interface {
	pulumi.Input

	ToPermissionsDatabasePtrOutput() PermissionsDatabasePtrOutput
	ToPermissionsDatabasePtrOutputWithContext(context.Context) PermissionsDatabasePtrOutput
}

type permissionsDatabasePtrType PermissionsDatabaseArgs

func PermissionsDatabasePtr(v *PermissionsDatabaseArgs) PermissionsDatabasePtrInput {
	return (*permissionsDatabasePtrType)(v)
}

func (*permissionsDatabasePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**PermissionsDatabase)(nil)).Elem()
}

func (i *permissionsDatabasePtrType) ToPermissionsDatabasePtrOutput() PermissionsDatabasePtrOutput {
	return i.ToPermissionsDatabasePtrOutputWithContext(context.Background())
}

func (i *permissionsDatabasePtrType) ToPermissionsDatabasePtrOutputWithContext(ctx context.Context) PermissionsDatabasePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PermissionsDatabasePtrOutput)
}

type PermissionsDatabaseOutput struct{ *pulumi.OutputState }

func (PermissionsDatabaseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PermissionsDatabase)(nil)).Elem()
}

func (o PermissionsDatabaseOutput) ToPermissionsDatabaseOutput() PermissionsDatabaseOutput {
	return o
}

func (o PermissionsDatabaseOutput) ToPermissionsDatabaseOutputWithContext(ctx context.Context) PermissionsDatabaseOutput {
	return o
}

func (o PermissionsDatabaseOutput) ToPermissionsDatabasePtrOutput() PermissionsDatabasePtrOutput {
	return o.ToPermissionsDatabasePtrOutputWithContext(context.Background())
}

func (o PermissionsDatabaseOutput) ToPermissionsDatabasePtrOutputWithContext(ctx context.Context) PermissionsDatabasePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v PermissionsDatabase) *PermissionsDatabase {
		return &v
	}).(PermissionsDatabasePtrOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o PermissionsDatabaseOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PermissionsDatabase) *string { return v.CatalogId }).(pulumi.StringPtrOutput)
}

// Name of the database resource. Unique to the Data Catalog.
//
// The following argument is optional:
func (o PermissionsDatabaseOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v PermissionsDatabase) string { return v.Name }).(pulumi.StringOutput)
}

type PermissionsDatabasePtrOutput struct{ *pulumi.OutputState }

func (PermissionsDatabasePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**PermissionsDatabase)(nil)).Elem()
}

func (o PermissionsDatabasePtrOutput) ToPermissionsDatabasePtrOutput() PermissionsDatabasePtrOutput {
	return o
}

func (o PermissionsDatabasePtrOutput) ToPermissionsDatabasePtrOutputWithContext(ctx context.Context) PermissionsDatabasePtrOutput {
	return o
}

func (o PermissionsDatabasePtrOutput) Elem() PermissionsDatabaseOutput {
	return o.ApplyT(func(v *PermissionsDatabase) PermissionsDatabase {
		if v != nil {
			return *v
		}
		var ret PermissionsDatabase
		return ret
	}).(PermissionsDatabaseOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o PermissionsDatabasePtrOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PermissionsDatabase) *string {
		if v == nil {
			return nil
		}
		return v.CatalogId
	}).(pulumi.StringPtrOutput)
}

// Name of the database resource. Unique to the Data Catalog.
//
// The following argument is optional:
func (o PermissionsDatabasePtrOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PermissionsDatabase) *string {
		if v == nil {
			return nil
		}
		return &v.Name
	}).(pulumi.StringPtrOutput)
}

type PermissionsLfTag struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId *string `pulumi:"catalogId"`
	// The key-name for the tag.
	Key string `pulumi:"key"`
	// A list of possible values an attribute can take.
	//
	// The following argument is optional:
	Values []string `pulumi:"values"`
}

// PermissionsLfTagInput is an input type that accepts PermissionsLfTagArgs and PermissionsLfTagOutput values.
// You can construct a concrete instance of `PermissionsLfTagInput` via:
//
//	PermissionsLfTagArgs{...}
type PermissionsLfTagInput interface {
	pulumi.Input

	ToPermissionsLfTagOutput() PermissionsLfTagOutput
	ToPermissionsLfTagOutputWithContext(context.Context) PermissionsLfTagOutput
}

type PermissionsLfTagArgs struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId pulumi.StringPtrInput `pulumi:"catalogId"`
	// The key-name for the tag.
	Key pulumi.StringInput `pulumi:"key"`
	// A list of possible values an attribute can take.
	//
	// The following argument is optional:
	Values pulumi.StringArrayInput `pulumi:"values"`
}

func (PermissionsLfTagArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*PermissionsLfTag)(nil)).Elem()
}

func (i PermissionsLfTagArgs) ToPermissionsLfTagOutput() PermissionsLfTagOutput {
	return i.ToPermissionsLfTagOutputWithContext(context.Background())
}

func (i PermissionsLfTagArgs) ToPermissionsLfTagOutputWithContext(ctx context.Context) PermissionsLfTagOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PermissionsLfTagOutput)
}

func (i PermissionsLfTagArgs) ToPermissionsLfTagPtrOutput() PermissionsLfTagPtrOutput {
	return i.ToPermissionsLfTagPtrOutputWithContext(context.Background())
}

func (i PermissionsLfTagArgs) ToPermissionsLfTagPtrOutputWithContext(ctx context.Context) PermissionsLfTagPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PermissionsLfTagOutput).ToPermissionsLfTagPtrOutputWithContext(ctx)
}

// PermissionsLfTagPtrInput is an input type that accepts PermissionsLfTagArgs, PermissionsLfTagPtr and PermissionsLfTagPtrOutput values.
// You can construct a concrete instance of `PermissionsLfTagPtrInput` via:
//
//	        PermissionsLfTagArgs{...}
//
//	or:
//
//	        nil
type PermissionsLfTagPtrInput interface {
	pulumi.Input

	ToPermissionsLfTagPtrOutput() PermissionsLfTagPtrOutput
	ToPermissionsLfTagPtrOutputWithContext(context.Context) PermissionsLfTagPtrOutput
}

type permissionsLfTagPtrType PermissionsLfTagArgs

func PermissionsLfTagPtr(v *PermissionsLfTagArgs) PermissionsLfTagPtrInput {
	return (*permissionsLfTagPtrType)(v)
}

func (*permissionsLfTagPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**PermissionsLfTag)(nil)).Elem()
}

func (i *permissionsLfTagPtrType) ToPermissionsLfTagPtrOutput() PermissionsLfTagPtrOutput {
	return i.ToPermissionsLfTagPtrOutputWithContext(context.Background())
}

func (i *permissionsLfTagPtrType) ToPermissionsLfTagPtrOutputWithContext(ctx context.Context) PermissionsLfTagPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PermissionsLfTagPtrOutput)
}

type PermissionsLfTagOutput struct{ *pulumi.OutputState }

func (PermissionsLfTagOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PermissionsLfTag)(nil)).Elem()
}

func (o PermissionsLfTagOutput) ToPermissionsLfTagOutput() PermissionsLfTagOutput {
	return o
}

func (o PermissionsLfTagOutput) ToPermissionsLfTagOutputWithContext(ctx context.Context) PermissionsLfTagOutput {
	return o
}

func (o PermissionsLfTagOutput) ToPermissionsLfTagPtrOutput() PermissionsLfTagPtrOutput {
	return o.ToPermissionsLfTagPtrOutputWithContext(context.Background())
}

func (o PermissionsLfTagOutput) ToPermissionsLfTagPtrOutputWithContext(ctx context.Context) PermissionsLfTagPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v PermissionsLfTag) *PermissionsLfTag {
		return &v
	}).(PermissionsLfTagPtrOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o PermissionsLfTagOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PermissionsLfTag) *string { return v.CatalogId }).(pulumi.StringPtrOutput)
}

// The key-name for the tag.
func (o PermissionsLfTagOutput) Key() pulumi.StringOutput {
	return o.ApplyT(func(v PermissionsLfTag) string { return v.Key }).(pulumi.StringOutput)
}

// A list of possible values an attribute can take.
//
// The following argument is optional:
func (o PermissionsLfTagOutput) Values() pulumi.StringArrayOutput {
	return o.ApplyT(func(v PermissionsLfTag) []string { return v.Values }).(pulumi.StringArrayOutput)
}

type PermissionsLfTagPtrOutput struct{ *pulumi.OutputState }

func (PermissionsLfTagPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**PermissionsLfTag)(nil)).Elem()
}

func (o PermissionsLfTagPtrOutput) ToPermissionsLfTagPtrOutput() PermissionsLfTagPtrOutput {
	return o
}

func (o PermissionsLfTagPtrOutput) ToPermissionsLfTagPtrOutputWithContext(ctx context.Context) PermissionsLfTagPtrOutput {
	return o
}

func (o PermissionsLfTagPtrOutput) Elem() PermissionsLfTagOutput {
	return o.ApplyT(func(v *PermissionsLfTag) PermissionsLfTag {
		if v != nil {
			return *v
		}
		var ret PermissionsLfTag
		return ret
	}).(PermissionsLfTagOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o PermissionsLfTagPtrOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PermissionsLfTag) *string {
		if v == nil {
			return nil
		}
		return v.CatalogId
	}).(pulumi.StringPtrOutput)
}

// The key-name for the tag.
func (o PermissionsLfTagPtrOutput) Key() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PermissionsLfTag) *string {
		if v == nil {
			return nil
		}
		return &v.Key
	}).(pulumi.StringPtrOutput)
}

// A list of possible values an attribute can take.
//
// The following argument is optional:
func (o PermissionsLfTagPtrOutput) Values() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *PermissionsLfTag) []string {
		if v == nil {
			return nil
		}
		return v.Values
	}).(pulumi.StringArrayOutput)
}

type PermissionsLfTagPolicy struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId *string `pulumi:"catalogId"`
	// A list of tag conditions that apply to the resource's tag policy. Configuration block for tag conditions that apply to the policy. See `expression` below.
	//
	// The following argument is optional:
	Expressions []PermissionsLfTagPolicyExpression `pulumi:"expressions"`
	// The resource type for which the tag policy applies. Valid values are `DATABASE` and `TABLE`.
	ResourceType string `pulumi:"resourceType"`
}

// PermissionsLfTagPolicyInput is an input type that accepts PermissionsLfTagPolicyArgs and PermissionsLfTagPolicyOutput values.
// You can construct a concrete instance of `PermissionsLfTagPolicyInput` via:
//
//	PermissionsLfTagPolicyArgs{...}
type PermissionsLfTagPolicyInput interface {
	pulumi.Input

	ToPermissionsLfTagPolicyOutput() PermissionsLfTagPolicyOutput
	ToPermissionsLfTagPolicyOutputWithContext(context.Context) PermissionsLfTagPolicyOutput
}

type PermissionsLfTagPolicyArgs struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId pulumi.StringPtrInput `pulumi:"catalogId"`
	// A list of tag conditions that apply to the resource's tag policy. Configuration block for tag conditions that apply to the policy. See `expression` below.
	//
	// The following argument is optional:
	Expressions PermissionsLfTagPolicyExpressionArrayInput `pulumi:"expressions"`
	// The resource type for which the tag policy applies. Valid values are `DATABASE` and `TABLE`.
	ResourceType pulumi.StringInput `pulumi:"resourceType"`
}

func (PermissionsLfTagPolicyArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*PermissionsLfTagPolicy)(nil)).Elem()
}

func (i PermissionsLfTagPolicyArgs) ToPermissionsLfTagPolicyOutput() PermissionsLfTagPolicyOutput {
	return i.ToPermissionsLfTagPolicyOutputWithContext(context.Background())
}

func (i PermissionsLfTagPolicyArgs) ToPermissionsLfTagPolicyOutputWithContext(ctx context.Context) PermissionsLfTagPolicyOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PermissionsLfTagPolicyOutput)
}

func (i PermissionsLfTagPolicyArgs) ToPermissionsLfTagPolicyPtrOutput() PermissionsLfTagPolicyPtrOutput {
	return i.ToPermissionsLfTagPolicyPtrOutputWithContext(context.Background())
}

func (i PermissionsLfTagPolicyArgs) ToPermissionsLfTagPolicyPtrOutputWithContext(ctx context.Context) PermissionsLfTagPolicyPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PermissionsLfTagPolicyOutput).ToPermissionsLfTagPolicyPtrOutputWithContext(ctx)
}

// PermissionsLfTagPolicyPtrInput is an input type that accepts PermissionsLfTagPolicyArgs, PermissionsLfTagPolicyPtr and PermissionsLfTagPolicyPtrOutput values.
// You can construct a concrete instance of `PermissionsLfTagPolicyPtrInput` via:
//
//	        PermissionsLfTagPolicyArgs{...}
//
//	or:
//
//	        nil
type PermissionsLfTagPolicyPtrInput interface {
	pulumi.Input

	ToPermissionsLfTagPolicyPtrOutput() PermissionsLfTagPolicyPtrOutput
	ToPermissionsLfTagPolicyPtrOutputWithContext(context.Context) PermissionsLfTagPolicyPtrOutput
}

type permissionsLfTagPolicyPtrType PermissionsLfTagPolicyArgs

func PermissionsLfTagPolicyPtr(v *PermissionsLfTagPolicyArgs) PermissionsLfTagPolicyPtrInput {
	return (*permissionsLfTagPolicyPtrType)(v)
}

func (*permissionsLfTagPolicyPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**PermissionsLfTagPolicy)(nil)).Elem()
}

func (i *permissionsLfTagPolicyPtrType) ToPermissionsLfTagPolicyPtrOutput() PermissionsLfTagPolicyPtrOutput {
	return i.ToPermissionsLfTagPolicyPtrOutputWithContext(context.Background())
}

func (i *permissionsLfTagPolicyPtrType) ToPermissionsLfTagPolicyPtrOutputWithContext(ctx context.Context) PermissionsLfTagPolicyPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PermissionsLfTagPolicyPtrOutput)
}

type PermissionsLfTagPolicyOutput struct{ *pulumi.OutputState }

func (PermissionsLfTagPolicyOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PermissionsLfTagPolicy)(nil)).Elem()
}

func (o PermissionsLfTagPolicyOutput) ToPermissionsLfTagPolicyOutput() PermissionsLfTagPolicyOutput {
	return o
}

func (o PermissionsLfTagPolicyOutput) ToPermissionsLfTagPolicyOutputWithContext(ctx context.Context) PermissionsLfTagPolicyOutput {
	return o
}

func (o PermissionsLfTagPolicyOutput) ToPermissionsLfTagPolicyPtrOutput() PermissionsLfTagPolicyPtrOutput {
	return o.ToPermissionsLfTagPolicyPtrOutputWithContext(context.Background())
}

func (o PermissionsLfTagPolicyOutput) ToPermissionsLfTagPolicyPtrOutputWithContext(ctx context.Context) PermissionsLfTagPolicyPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v PermissionsLfTagPolicy) *PermissionsLfTagPolicy {
		return &v
	}).(PermissionsLfTagPolicyPtrOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o PermissionsLfTagPolicyOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PermissionsLfTagPolicy) *string { return v.CatalogId }).(pulumi.StringPtrOutput)
}

// A list of tag conditions that apply to the resource's tag policy. Configuration block for tag conditions that apply to the policy. See `expression` below.
//
// The following argument is optional:
func (o PermissionsLfTagPolicyOutput) Expressions() PermissionsLfTagPolicyExpressionArrayOutput {
	return o.ApplyT(func(v PermissionsLfTagPolicy) []PermissionsLfTagPolicyExpression { return v.Expressions }).(PermissionsLfTagPolicyExpressionArrayOutput)
}

// The resource type for which the tag policy applies. Valid values are `DATABASE` and `TABLE`.
func (o PermissionsLfTagPolicyOutput) ResourceType() pulumi.StringOutput {
	return o.ApplyT(func(v PermissionsLfTagPolicy) string { return v.ResourceType }).(pulumi.StringOutput)
}

type PermissionsLfTagPolicyPtrOutput struct{ *pulumi.OutputState }

func (PermissionsLfTagPolicyPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**PermissionsLfTagPolicy)(nil)).Elem()
}

func (o PermissionsLfTagPolicyPtrOutput) ToPermissionsLfTagPolicyPtrOutput() PermissionsLfTagPolicyPtrOutput {
	return o
}

func (o PermissionsLfTagPolicyPtrOutput) ToPermissionsLfTagPolicyPtrOutputWithContext(ctx context.Context) PermissionsLfTagPolicyPtrOutput {
	return o
}

func (o PermissionsLfTagPolicyPtrOutput) Elem() PermissionsLfTagPolicyOutput {
	return o.ApplyT(func(v *PermissionsLfTagPolicy) PermissionsLfTagPolicy {
		if v != nil {
			return *v
		}
		var ret PermissionsLfTagPolicy
		return ret
	}).(PermissionsLfTagPolicyOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o PermissionsLfTagPolicyPtrOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PermissionsLfTagPolicy) *string {
		if v == nil {
			return nil
		}
		return v.CatalogId
	}).(pulumi.StringPtrOutput)
}

// A list of tag conditions that apply to the resource's tag policy. Configuration block for tag conditions that apply to the policy. See `expression` below.
//
// The following argument is optional:
func (o PermissionsLfTagPolicyPtrOutput) Expressions() PermissionsLfTagPolicyExpressionArrayOutput {
	return o.ApplyT(func(v *PermissionsLfTagPolicy) []PermissionsLfTagPolicyExpression {
		if v == nil {
			return nil
		}
		return v.Expressions
	}).(PermissionsLfTagPolicyExpressionArrayOutput)
}

// The resource type for which the tag policy applies. Valid values are `DATABASE` and `TABLE`.
func (o PermissionsLfTagPolicyPtrOutput) ResourceType() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PermissionsLfTagPolicy) *string {
		if v == nil {
			return nil
		}
		return &v.ResourceType
	}).(pulumi.StringPtrOutput)
}

type PermissionsLfTagPolicyExpression struct {
	// The key-name of an LF-Tag.
	Key string `pulumi:"key"`
	// A list of possible values of an LF-Tag.
	Values []string `pulumi:"values"`
}

// PermissionsLfTagPolicyExpressionInput is an input type that accepts PermissionsLfTagPolicyExpressionArgs and PermissionsLfTagPolicyExpressionOutput values.
// You can construct a concrete instance of `PermissionsLfTagPolicyExpressionInput` via:
//
//	PermissionsLfTagPolicyExpressionArgs{...}
type PermissionsLfTagPolicyExpressionInput interface {
	pulumi.Input

	ToPermissionsLfTagPolicyExpressionOutput() PermissionsLfTagPolicyExpressionOutput
	ToPermissionsLfTagPolicyExpressionOutputWithContext(context.Context) PermissionsLfTagPolicyExpressionOutput
}

type PermissionsLfTagPolicyExpressionArgs struct {
	// The key-name of an LF-Tag.
	Key pulumi.StringInput `pulumi:"key"`
	// A list of possible values of an LF-Tag.
	Values pulumi.StringArrayInput `pulumi:"values"`
}

func (PermissionsLfTagPolicyExpressionArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*PermissionsLfTagPolicyExpression)(nil)).Elem()
}

func (i PermissionsLfTagPolicyExpressionArgs) ToPermissionsLfTagPolicyExpressionOutput() PermissionsLfTagPolicyExpressionOutput {
	return i.ToPermissionsLfTagPolicyExpressionOutputWithContext(context.Background())
}

func (i PermissionsLfTagPolicyExpressionArgs) ToPermissionsLfTagPolicyExpressionOutputWithContext(ctx context.Context) PermissionsLfTagPolicyExpressionOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PermissionsLfTagPolicyExpressionOutput)
}

// PermissionsLfTagPolicyExpressionArrayInput is an input type that accepts PermissionsLfTagPolicyExpressionArray and PermissionsLfTagPolicyExpressionArrayOutput values.
// You can construct a concrete instance of `PermissionsLfTagPolicyExpressionArrayInput` via:
//
//	PermissionsLfTagPolicyExpressionArray{ PermissionsLfTagPolicyExpressionArgs{...} }
type PermissionsLfTagPolicyExpressionArrayInput interface {
	pulumi.Input

	ToPermissionsLfTagPolicyExpressionArrayOutput() PermissionsLfTagPolicyExpressionArrayOutput
	ToPermissionsLfTagPolicyExpressionArrayOutputWithContext(context.Context) PermissionsLfTagPolicyExpressionArrayOutput
}

type PermissionsLfTagPolicyExpressionArray []PermissionsLfTagPolicyExpressionInput

func (PermissionsLfTagPolicyExpressionArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]PermissionsLfTagPolicyExpression)(nil)).Elem()
}

func (i PermissionsLfTagPolicyExpressionArray) ToPermissionsLfTagPolicyExpressionArrayOutput() PermissionsLfTagPolicyExpressionArrayOutput {
	return i.ToPermissionsLfTagPolicyExpressionArrayOutputWithContext(context.Background())
}

func (i PermissionsLfTagPolicyExpressionArray) ToPermissionsLfTagPolicyExpressionArrayOutputWithContext(ctx context.Context) PermissionsLfTagPolicyExpressionArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PermissionsLfTagPolicyExpressionArrayOutput)
}

type PermissionsLfTagPolicyExpressionOutput struct{ *pulumi.OutputState }

func (PermissionsLfTagPolicyExpressionOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PermissionsLfTagPolicyExpression)(nil)).Elem()
}

func (o PermissionsLfTagPolicyExpressionOutput) ToPermissionsLfTagPolicyExpressionOutput() PermissionsLfTagPolicyExpressionOutput {
	return o
}

func (o PermissionsLfTagPolicyExpressionOutput) ToPermissionsLfTagPolicyExpressionOutputWithContext(ctx context.Context) PermissionsLfTagPolicyExpressionOutput {
	return o
}

// The key-name of an LF-Tag.
func (o PermissionsLfTagPolicyExpressionOutput) Key() pulumi.StringOutput {
	return o.ApplyT(func(v PermissionsLfTagPolicyExpression) string { return v.Key }).(pulumi.StringOutput)
}

// A list of possible values of an LF-Tag.
func (o PermissionsLfTagPolicyExpressionOutput) Values() pulumi.StringArrayOutput {
	return o.ApplyT(func(v PermissionsLfTagPolicyExpression) []string { return v.Values }).(pulumi.StringArrayOutput)
}

type PermissionsLfTagPolicyExpressionArrayOutput struct{ *pulumi.OutputState }

func (PermissionsLfTagPolicyExpressionArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]PermissionsLfTagPolicyExpression)(nil)).Elem()
}

func (o PermissionsLfTagPolicyExpressionArrayOutput) ToPermissionsLfTagPolicyExpressionArrayOutput() PermissionsLfTagPolicyExpressionArrayOutput {
	return o
}

func (o PermissionsLfTagPolicyExpressionArrayOutput) ToPermissionsLfTagPolicyExpressionArrayOutputWithContext(ctx context.Context) PermissionsLfTagPolicyExpressionArrayOutput {
	return o
}

func (o PermissionsLfTagPolicyExpressionArrayOutput) Index(i pulumi.IntInput) PermissionsLfTagPolicyExpressionOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) PermissionsLfTagPolicyExpression {
		return vs[0].([]PermissionsLfTagPolicyExpression)[vs[1].(int)]
	}).(PermissionsLfTagPolicyExpressionOutput)
}

type PermissionsTable struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId *string `pulumi:"catalogId"`
	// Name of the database for the table. Unique to a Data Catalog.
	DatabaseName string `pulumi:"databaseName"`
	// Name of the table.
	Name *string `pulumi:"name"`
	// Whether to use a wildcard representing every table under a database. Defaults to `false`.
	//
	// The following arguments are optional:
	Wildcard *bool `pulumi:"wildcard"`
}

// PermissionsTableInput is an input type that accepts PermissionsTableArgs and PermissionsTableOutput values.
// You can construct a concrete instance of `PermissionsTableInput` via:
//
//	PermissionsTableArgs{...}
type PermissionsTableInput interface {
	pulumi.Input

	ToPermissionsTableOutput() PermissionsTableOutput
	ToPermissionsTableOutputWithContext(context.Context) PermissionsTableOutput
}

type PermissionsTableArgs struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId pulumi.StringPtrInput `pulumi:"catalogId"`
	// Name of the database for the table. Unique to a Data Catalog.
	DatabaseName pulumi.StringInput `pulumi:"databaseName"`
	// Name of the table.
	Name pulumi.StringPtrInput `pulumi:"name"`
	// Whether to use a wildcard representing every table under a database. Defaults to `false`.
	//
	// The following arguments are optional:
	Wildcard pulumi.BoolPtrInput `pulumi:"wildcard"`
}

func (PermissionsTableArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*PermissionsTable)(nil)).Elem()
}

func (i PermissionsTableArgs) ToPermissionsTableOutput() PermissionsTableOutput {
	return i.ToPermissionsTableOutputWithContext(context.Background())
}

func (i PermissionsTableArgs) ToPermissionsTableOutputWithContext(ctx context.Context) PermissionsTableOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PermissionsTableOutput)
}

func (i PermissionsTableArgs) ToPermissionsTablePtrOutput() PermissionsTablePtrOutput {
	return i.ToPermissionsTablePtrOutputWithContext(context.Background())
}

func (i PermissionsTableArgs) ToPermissionsTablePtrOutputWithContext(ctx context.Context) PermissionsTablePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PermissionsTableOutput).ToPermissionsTablePtrOutputWithContext(ctx)
}

// PermissionsTablePtrInput is an input type that accepts PermissionsTableArgs, PermissionsTablePtr and PermissionsTablePtrOutput values.
// You can construct a concrete instance of `PermissionsTablePtrInput` via:
//
//	        PermissionsTableArgs{...}
//
//	or:
//
//	        nil
type PermissionsTablePtrInput interface {
	pulumi.Input

	ToPermissionsTablePtrOutput() PermissionsTablePtrOutput
	ToPermissionsTablePtrOutputWithContext(context.Context) PermissionsTablePtrOutput
}

type permissionsTablePtrType PermissionsTableArgs

func PermissionsTablePtr(v *PermissionsTableArgs) PermissionsTablePtrInput {
	return (*permissionsTablePtrType)(v)
}

func (*permissionsTablePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**PermissionsTable)(nil)).Elem()
}

func (i *permissionsTablePtrType) ToPermissionsTablePtrOutput() PermissionsTablePtrOutput {
	return i.ToPermissionsTablePtrOutputWithContext(context.Background())
}

func (i *permissionsTablePtrType) ToPermissionsTablePtrOutputWithContext(ctx context.Context) PermissionsTablePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PermissionsTablePtrOutput)
}

type PermissionsTableOutput struct{ *pulumi.OutputState }

func (PermissionsTableOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PermissionsTable)(nil)).Elem()
}

func (o PermissionsTableOutput) ToPermissionsTableOutput() PermissionsTableOutput {
	return o
}

func (o PermissionsTableOutput) ToPermissionsTableOutputWithContext(ctx context.Context) PermissionsTableOutput {
	return o
}

func (o PermissionsTableOutput) ToPermissionsTablePtrOutput() PermissionsTablePtrOutput {
	return o.ToPermissionsTablePtrOutputWithContext(context.Background())
}

func (o PermissionsTableOutput) ToPermissionsTablePtrOutputWithContext(ctx context.Context) PermissionsTablePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v PermissionsTable) *PermissionsTable {
		return &v
	}).(PermissionsTablePtrOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o PermissionsTableOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PermissionsTable) *string { return v.CatalogId }).(pulumi.StringPtrOutput)
}

// Name of the database for the table. Unique to a Data Catalog.
func (o PermissionsTableOutput) DatabaseName() pulumi.StringOutput {
	return o.ApplyT(func(v PermissionsTable) string { return v.DatabaseName }).(pulumi.StringOutput)
}

// Name of the table.
func (o PermissionsTableOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PermissionsTable) *string { return v.Name }).(pulumi.StringPtrOutput)
}

// Whether to use a wildcard representing every table under a database. Defaults to `false`.
//
// The following arguments are optional:
func (o PermissionsTableOutput) Wildcard() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v PermissionsTable) *bool { return v.Wildcard }).(pulumi.BoolPtrOutput)
}

type PermissionsTablePtrOutput struct{ *pulumi.OutputState }

func (PermissionsTablePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**PermissionsTable)(nil)).Elem()
}

func (o PermissionsTablePtrOutput) ToPermissionsTablePtrOutput() PermissionsTablePtrOutput {
	return o
}

func (o PermissionsTablePtrOutput) ToPermissionsTablePtrOutputWithContext(ctx context.Context) PermissionsTablePtrOutput {
	return o
}

func (o PermissionsTablePtrOutput) Elem() PermissionsTableOutput {
	return o.ApplyT(func(v *PermissionsTable) PermissionsTable {
		if v != nil {
			return *v
		}
		var ret PermissionsTable
		return ret
	}).(PermissionsTableOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o PermissionsTablePtrOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PermissionsTable) *string {
		if v == nil {
			return nil
		}
		return v.CatalogId
	}).(pulumi.StringPtrOutput)
}

// Name of the database for the table. Unique to a Data Catalog.
func (o PermissionsTablePtrOutput) DatabaseName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PermissionsTable) *string {
		if v == nil {
			return nil
		}
		return &v.DatabaseName
	}).(pulumi.StringPtrOutput)
}

// Name of the table.
func (o PermissionsTablePtrOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PermissionsTable) *string {
		if v == nil {
			return nil
		}
		return v.Name
	}).(pulumi.StringPtrOutput)
}

// Whether to use a wildcard representing every table under a database. Defaults to `false`.
//
// The following arguments are optional:
func (o PermissionsTablePtrOutput) Wildcard() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *PermissionsTable) *bool {
		if v == nil {
			return nil
		}
		return v.Wildcard
	}).(pulumi.BoolPtrOutput)
}

type PermissionsTableWithColumns struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId *string `pulumi:"catalogId"`
	// Set of column names for the table.
	ColumnNames []string `pulumi:"columnNames"`
	// Name of the database for the table with columns resource. Unique to the Data Catalog.
	DatabaseName string `pulumi:"databaseName"`
	// Set of column names for the table to exclude. If `excludedColumnNames` is included, `wildcard` must be set to `true` to avoid the provider reporting a difference.
	ExcludedColumnNames []string `pulumi:"excludedColumnNames"`
	// Name of the table resource.
	Name string `pulumi:"name"`
	// Whether to use a column wildcard. If `excludedColumnNames` is included, `wildcard` must be set to `true` to avoid the provider reporting a difference.
	//
	// The following arguments are optional:
	Wildcard *bool `pulumi:"wildcard"`
}

// PermissionsTableWithColumnsInput is an input type that accepts PermissionsTableWithColumnsArgs and PermissionsTableWithColumnsOutput values.
// You can construct a concrete instance of `PermissionsTableWithColumnsInput` via:
//
//	PermissionsTableWithColumnsArgs{...}
type PermissionsTableWithColumnsInput interface {
	pulumi.Input

	ToPermissionsTableWithColumnsOutput() PermissionsTableWithColumnsOutput
	ToPermissionsTableWithColumnsOutputWithContext(context.Context) PermissionsTableWithColumnsOutput
}

type PermissionsTableWithColumnsArgs struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId pulumi.StringPtrInput `pulumi:"catalogId"`
	// Set of column names for the table.
	ColumnNames pulumi.StringArrayInput `pulumi:"columnNames"`
	// Name of the database for the table with columns resource. Unique to the Data Catalog.
	DatabaseName pulumi.StringInput `pulumi:"databaseName"`
	// Set of column names for the table to exclude. If `excludedColumnNames` is included, `wildcard` must be set to `true` to avoid the provider reporting a difference.
	ExcludedColumnNames pulumi.StringArrayInput `pulumi:"excludedColumnNames"`
	// Name of the table resource.
	Name pulumi.StringInput `pulumi:"name"`
	// Whether to use a column wildcard. If `excludedColumnNames` is included, `wildcard` must be set to `true` to avoid the provider reporting a difference.
	//
	// The following arguments are optional:
	Wildcard pulumi.BoolPtrInput `pulumi:"wildcard"`
}

func (PermissionsTableWithColumnsArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*PermissionsTableWithColumns)(nil)).Elem()
}

func (i PermissionsTableWithColumnsArgs) ToPermissionsTableWithColumnsOutput() PermissionsTableWithColumnsOutput {
	return i.ToPermissionsTableWithColumnsOutputWithContext(context.Background())
}

func (i PermissionsTableWithColumnsArgs) ToPermissionsTableWithColumnsOutputWithContext(ctx context.Context) PermissionsTableWithColumnsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PermissionsTableWithColumnsOutput)
}

func (i PermissionsTableWithColumnsArgs) ToPermissionsTableWithColumnsPtrOutput() PermissionsTableWithColumnsPtrOutput {
	return i.ToPermissionsTableWithColumnsPtrOutputWithContext(context.Background())
}

func (i PermissionsTableWithColumnsArgs) ToPermissionsTableWithColumnsPtrOutputWithContext(ctx context.Context) PermissionsTableWithColumnsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PermissionsTableWithColumnsOutput).ToPermissionsTableWithColumnsPtrOutputWithContext(ctx)
}

// PermissionsTableWithColumnsPtrInput is an input type that accepts PermissionsTableWithColumnsArgs, PermissionsTableWithColumnsPtr and PermissionsTableWithColumnsPtrOutput values.
// You can construct a concrete instance of `PermissionsTableWithColumnsPtrInput` via:
//
//	        PermissionsTableWithColumnsArgs{...}
//
//	or:
//
//	        nil
type PermissionsTableWithColumnsPtrInput interface {
	pulumi.Input

	ToPermissionsTableWithColumnsPtrOutput() PermissionsTableWithColumnsPtrOutput
	ToPermissionsTableWithColumnsPtrOutputWithContext(context.Context) PermissionsTableWithColumnsPtrOutput
}

type permissionsTableWithColumnsPtrType PermissionsTableWithColumnsArgs

func PermissionsTableWithColumnsPtr(v *PermissionsTableWithColumnsArgs) PermissionsTableWithColumnsPtrInput {
	return (*permissionsTableWithColumnsPtrType)(v)
}

func (*permissionsTableWithColumnsPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**PermissionsTableWithColumns)(nil)).Elem()
}

func (i *permissionsTableWithColumnsPtrType) ToPermissionsTableWithColumnsPtrOutput() PermissionsTableWithColumnsPtrOutput {
	return i.ToPermissionsTableWithColumnsPtrOutputWithContext(context.Background())
}

func (i *permissionsTableWithColumnsPtrType) ToPermissionsTableWithColumnsPtrOutputWithContext(ctx context.Context) PermissionsTableWithColumnsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(PermissionsTableWithColumnsPtrOutput)
}

type PermissionsTableWithColumnsOutput struct{ *pulumi.OutputState }

func (PermissionsTableWithColumnsOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*PermissionsTableWithColumns)(nil)).Elem()
}

func (o PermissionsTableWithColumnsOutput) ToPermissionsTableWithColumnsOutput() PermissionsTableWithColumnsOutput {
	return o
}

func (o PermissionsTableWithColumnsOutput) ToPermissionsTableWithColumnsOutputWithContext(ctx context.Context) PermissionsTableWithColumnsOutput {
	return o
}

func (o PermissionsTableWithColumnsOutput) ToPermissionsTableWithColumnsPtrOutput() PermissionsTableWithColumnsPtrOutput {
	return o.ToPermissionsTableWithColumnsPtrOutputWithContext(context.Background())
}

func (o PermissionsTableWithColumnsOutput) ToPermissionsTableWithColumnsPtrOutputWithContext(ctx context.Context) PermissionsTableWithColumnsPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v PermissionsTableWithColumns) *PermissionsTableWithColumns {
		return &v
	}).(PermissionsTableWithColumnsPtrOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o PermissionsTableWithColumnsOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v PermissionsTableWithColumns) *string { return v.CatalogId }).(pulumi.StringPtrOutput)
}

// Set of column names for the table.
func (o PermissionsTableWithColumnsOutput) ColumnNames() pulumi.StringArrayOutput {
	return o.ApplyT(func(v PermissionsTableWithColumns) []string { return v.ColumnNames }).(pulumi.StringArrayOutput)
}

// Name of the database for the table with columns resource. Unique to the Data Catalog.
func (o PermissionsTableWithColumnsOutput) DatabaseName() pulumi.StringOutput {
	return o.ApplyT(func(v PermissionsTableWithColumns) string { return v.DatabaseName }).(pulumi.StringOutput)
}

// Set of column names for the table to exclude. If `excludedColumnNames` is included, `wildcard` must be set to `true` to avoid the provider reporting a difference.
func (o PermissionsTableWithColumnsOutput) ExcludedColumnNames() pulumi.StringArrayOutput {
	return o.ApplyT(func(v PermissionsTableWithColumns) []string { return v.ExcludedColumnNames }).(pulumi.StringArrayOutput)
}

// Name of the table resource.
func (o PermissionsTableWithColumnsOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v PermissionsTableWithColumns) string { return v.Name }).(pulumi.StringOutput)
}

// Whether to use a column wildcard. If `excludedColumnNames` is included, `wildcard` must be set to `true` to avoid the provider reporting a difference.
//
// The following arguments are optional:
func (o PermissionsTableWithColumnsOutput) Wildcard() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v PermissionsTableWithColumns) *bool { return v.Wildcard }).(pulumi.BoolPtrOutput)
}

type PermissionsTableWithColumnsPtrOutput struct{ *pulumi.OutputState }

func (PermissionsTableWithColumnsPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**PermissionsTableWithColumns)(nil)).Elem()
}

func (o PermissionsTableWithColumnsPtrOutput) ToPermissionsTableWithColumnsPtrOutput() PermissionsTableWithColumnsPtrOutput {
	return o
}

func (o PermissionsTableWithColumnsPtrOutput) ToPermissionsTableWithColumnsPtrOutputWithContext(ctx context.Context) PermissionsTableWithColumnsPtrOutput {
	return o
}

func (o PermissionsTableWithColumnsPtrOutput) Elem() PermissionsTableWithColumnsOutput {
	return o.ApplyT(func(v *PermissionsTableWithColumns) PermissionsTableWithColumns {
		if v != nil {
			return *v
		}
		var ret PermissionsTableWithColumns
		return ret
	}).(PermissionsTableWithColumnsOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o PermissionsTableWithColumnsPtrOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PermissionsTableWithColumns) *string {
		if v == nil {
			return nil
		}
		return v.CatalogId
	}).(pulumi.StringPtrOutput)
}

// Set of column names for the table.
func (o PermissionsTableWithColumnsPtrOutput) ColumnNames() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *PermissionsTableWithColumns) []string {
		if v == nil {
			return nil
		}
		return v.ColumnNames
	}).(pulumi.StringArrayOutput)
}

// Name of the database for the table with columns resource. Unique to the Data Catalog.
func (o PermissionsTableWithColumnsPtrOutput) DatabaseName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PermissionsTableWithColumns) *string {
		if v == nil {
			return nil
		}
		return &v.DatabaseName
	}).(pulumi.StringPtrOutput)
}

// Set of column names for the table to exclude. If `excludedColumnNames` is included, `wildcard` must be set to `true` to avoid the provider reporting a difference.
func (o PermissionsTableWithColumnsPtrOutput) ExcludedColumnNames() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *PermissionsTableWithColumns) []string {
		if v == nil {
			return nil
		}
		return v.ExcludedColumnNames
	}).(pulumi.StringArrayOutput)
}

// Name of the table resource.
func (o PermissionsTableWithColumnsPtrOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *PermissionsTableWithColumns) *string {
		if v == nil {
			return nil
		}
		return &v.Name
	}).(pulumi.StringPtrOutput)
}

// Whether to use a column wildcard. If `excludedColumnNames` is included, `wildcard` must be set to `true` to avoid the provider reporting a difference.
//
// The following arguments are optional:
func (o PermissionsTableWithColumnsPtrOutput) Wildcard() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *PermissionsTableWithColumns) *bool {
		if v == nil {
			return nil
		}
		return v.Wildcard
	}).(pulumi.BoolPtrOutput)
}

type ResourceLfTagDatabase struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId *string `pulumi:"catalogId"`
	// Name of the database resource. Unique to the Data Catalog.
	//
	// The following argument is optional:
	Name string `pulumi:"name"`
}

// ResourceLfTagDatabaseInput is an input type that accepts ResourceLfTagDatabaseArgs and ResourceLfTagDatabaseOutput values.
// You can construct a concrete instance of `ResourceLfTagDatabaseInput` via:
//
//	ResourceLfTagDatabaseArgs{...}
type ResourceLfTagDatabaseInput interface {
	pulumi.Input

	ToResourceLfTagDatabaseOutput() ResourceLfTagDatabaseOutput
	ToResourceLfTagDatabaseOutputWithContext(context.Context) ResourceLfTagDatabaseOutput
}

type ResourceLfTagDatabaseArgs struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId pulumi.StringPtrInput `pulumi:"catalogId"`
	// Name of the database resource. Unique to the Data Catalog.
	//
	// The following argument is optional:
	Name pulumi.StringInput `pulumi:"name"`
}

func (ResourceLfTagDatabaseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceLfTagDatabase)(nil)).Elem()
}

func (i ResourceLfTagDatabaseArgs) ToResourceLfTagDatabaseOutput() ResourceLfTagDatabaseOutput {
	return i.ToResourceLfTagDatabaseOutputWithContext(context.Background())
}

func (i ResourceLfTagDatabaseArgs) ToResourceLfTagDatabaseOutputWithContext(ctx context.Context) ResourceLfTagDatabaseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagDatabaseOutput)
}

func (i ResourceLfTagDatabaseArgs) ToResourceLfTagDatabasePtrOutput() ResourceLfTagDatabasePtrOutput {
	return i.ToResourceLfTagDatabasePtrOutputWithContext(context.Background())
}

func (i ResourceLfTagDatabaseArgs) ToResourceLfTagDatabasePtrOutputWithContext(ctx context.Context) ResourceLfTagDatabasePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagDatabaseOutput).ToResourceLfTagDatabasePtrOutputWithContext(ctx)
}

// ResourceLfTagDatabasePtrInput is an input type that accepts ResourceLfTagDatabaseArgs, ResourceLfTagDatabasePtr and ResourceLfTagDatabasePtrOutput values.
// You can construct a concrete instance of `ResourceLfTagDatabasePtrInput` via:
//
//	        ResourceLfTagDatabaseArgs{...}
//
//	or:
//
//	        nil
type ResourceLfTagDatabasePtrInput interface {
	pulumi.Input

	ToResourceLfTagDatabasePtrOutput() ResourceLfTagDatabasePtrOutput
	ToResourceLfTagDatabasePtrOutputWithContext(context.Context) ResourceLfTagDatabasePtrOutput
}

type resourceLfTagDatabasePtrType ResourceLfTagDatabaseArgs

func ResourceLfTagDatabasePtr(v *ResourceLfTagDatabaseArgs) ResourceLfTagDatabasePtrInput {
	return (*resourceLfTagDatabasePtrType)(v)
}

func (*resourceLfTagDatabasePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceLfTagDatabase)(nil)).Elem()
}

func (i *resourceLfTagDatabasePtrType) ToResourceLfTagDatabasePtrOutput() ResourceLfTagDatabasePtrOutput {
	return i.ToResourceLfTagDatabasePtrOutputWithContext(context.Background())
}

func (i *resourceLfTagDatabasePtrType) ToResourceLfTagDatabasePtrOutputWithContext(ctx context.Context) ResourceLfTagDatabasePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagDatabasePtrOutput)
}

type ResourceLfTagDatabaseOutput struct{ *pulumi.OutputState }

func (ResourceLfTagDatabaseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceLfTagDatabase)(nil)).Elem()
}

func (o ResourceLfTagDatabaseOutput) ToResourceLfTagDatabaseOutput() ResourceLfTagDatabaseOutput {
	return o
}

func (o ResourceLfTagDatabaseOutput) ToResourceLfTagDatabaseOutputWithContext(ctx context.Context) ResourceLfTagDatabaseOutput {
	return o
}

func (o ResourceLfTagDatabaseOutput) ToResourceLfTagDatabasePtrOutput() ResourceLfTagDatabasePtrOutput {
	return o.ToResourceLfTagDatabasePtrOutputWithContext(context.Background())
}

func (o ResourceLfTagDatabaseOutput) ToResourceLfTagDatabasePtrOutputWithContext(ctx context.Context) ResourceLfTagDatabasePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ResourceLfTagDatabase) *ResourceLfTagDatabase {
		return &v
	}).(ResourceLfTagDatabasePtrOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o ResourceLfTagDatabaseOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceLfTagDatabase) *string { return v.CatalogId }).(pulumi.StringPtrOutput)
}

// Name of the database resource. Unique to the Data Catalog.
//
// The following argument is optional:
func (o ResourceLfTagDatabaseOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v ResourceLfTagDatabase) string { return v.Name }).(pulumi.StringOutput)
}

type ResourceLfTagDatabasePtrOutput struct{ *pulumi.OutputState }

func (ResourceLfTagDatabasePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceLfTagDatabase)(nil)).Elem()
}

func (o ResourceLfTagDatabasePtrOutput) ToResourceLfTagDatabasePtrOutput() ResourceLfTagDatabasePtrOutput {
	return o
}

func (o ResourceLfTagDatabasePtrOutput) ToResourceLfTagDatabasePtrOutputWithContext(ctx context.Context) ResourceLfTagDatabasePtrOutput {
	return o
}

func (o ResourceLfTagDatabasePtrOutput) Elem() ResourceLfTagDatabaseOutput {
	return o.ApplyT(func(v *ResourceLfTagDatabase) ResourceLfTagDatabase {
		if v != nil {
			return *v
		}
		var ret ResourceLfTagDatabase
		return ret
	}).(ResourceLfTagDatabaseOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o ResourceLfTagDatabasePtrOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceLfTagDatabase) *string {
		if v == nil {
			return nil
		}
		return v.CatalogId
	}).(pulumi.StringPtrOutput)
}

// Name of the database resource. Unique to the Data Catalog.
//
// The following argument is optional:
func (o ResourceLfTagDatabasePtrOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceLfTagDatabase) *string {
		if v == nil {
			return nil
		}
		return &v.Name
	}).(pulumi.StringPtrOutput)
}

type ResourceLfTagLfTag struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId *string `pulumi:"catalogId"`
	// Key name for an existing LF-tag.
	Key string `pulumi:"key"`
	// Value from the possible values for the LF-tag.
	//
	// The following argument is optional:
	Value string `pulumi:"value"`
}

// ResourceLfTagLfTagInput is an input type that accepts ResourceLfTagLfTagArgs and ResourceLfTagLfTagOutput values.
// You can construct a concrete instance of `ResourceLfTagLfTagInput` via:
//
//	ResourceLfTagLfTagArgs{...}
type ResourceLfTagLfTagInput interface {
	pulumi.Input

	ToResourceLfTagLfTagOutput() ResourceLfTagLfTagOutput
	ToResourceLfTagLfTagOutputWithContext(context.Context) ResourceLfTagLfTagOutput
}

type ResourceLfTagLfTagArgs struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId pulumi.StringPtrInput `pulumi:"catalogId"`
	// Key name for an existing LF-tag.
	Key pulumi.StringInput `pulumi:"key"`
	// Value from the possible values for the LF-tag.
	//
	// The following argument is optional:
	Value pulumi.StringInput `pulumi:"value"`
}

func (ResourceLfTagLfTagArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceLfTagLfTag)(nil)).Elem()
}

func (i ResourceLfTagLfTagArgs) ToResourceLfTagLfTagOutput() ResourceLfTagLfTagOutput {
	return i.ToResourceLfTagLfTagOutputWithContext(context.Background())
}

func (i ResourceLfTagLfTagArgs) ToResourceLfTagLfTagOutputWithContext(ctx context.Context) ResourceLfTagLfTagOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagLfTagOutput)
}

func (i ResourceLfTagLfTagArgs) ToResourceLfTagLfTagPtrOutput() ResourceLfTagLfTagPtrOutput {
	return i.ToResourceLfTagLfTagPtrOutputWithContext(context.Background())
}

func (i ResourceLfTagLfTagArgs) ToResourceLfTagLfTagPtrOutputWithContext(ctx context.Context) ResourceLfTagLfTagPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagLfTagOutput).ToResourceLfTagLfTagPtrOutputWithContext(ctx)
}

// ResourceLfTagLfTagPtrInput is an input type that accepts ResourceLfTagLfTagArgs, ResourceLfTagLfTagPtr and ResourceLfTagLfTagPtrOutput values.
// You can construct a concrete instance of `ResourceLfTagLfTagPtrInput` via:
//
//	        ResourceLfTagLfTagArgs{...}
//
//	or:
//
//	        nil
type ResourceLfTagLfTagPtrInput interface {
	pulumi.Input

	ToResourceLfTagLfTagPtrOutput() ResourceLfTagLfTagPtrOutput
	ToResourceLfTagLfTagPtrOutputWithContext(context.Context) ResourceLfTagLfTagPtrOutput
}

type resourceLfTagLfTagPtrType ResourceLfTagLfTagArgs

func ResourceLfTagLfTagPtr(v *ResourceLfTagLfTagArgs) ResourceLfTagLfTagPtrInput {
	return (*resourceLfTagLfTagPtrType)(v)
}

func (*resourceLfTagLfTagPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceLfTagLfTag)(nil)).Elem()
}

func (i *resourceLfTagLfTagPtrType) ToResourceLfTagLfTagPtrOutput() ResourceLfTagLfTagPtrOutput {
	return i.ToResourceLfTagLfTagPtrOutputWithContext(context.Background())
}

func (i *resourceLfTagLfTagPtrType) ToResourceLfTagLfTagPtrOutputWithContext(ctx context.Context) ResourceLfTagLfTagPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagLfTagPtrOutput)
}

type ResourceLfTagLfTagOutput struct{ *pulumi.OutputState }

func (ResourceLfTagLfTagOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceLfTagLfTag)(nil)).Elem()
}

func (o ResourceLfTagLfTagOutput) ToResourceLfTagLfTagOutput() ResourceLfTagLfTagOutput {
	return o
}

func (o ResourceLfTagLfTagOutput) ToResourceLfTagLfTagOutputWithContext(ctx context.Context) ResourceLfTagLfTagOutput {
	return o
}

func (o ResourceLfTagLfTagOutput) ToResourceLfTagLfTagPtrOutput() ResourceLfTagLfTagPtrOutput {
	return o.ToResourceLfTagLfTagPtrOutputWithContext(context.Background())
}

func (o ResourceLfTagLfTagOutput) ToResourceLfTagLfTagPtrOutputWithContext(ctx context.Context) ResourceLfTagLfTagPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ResourceLfTagLfTag) *ResourceLfTagLfTag {
		return &v
	}).(ResourceLfTagLfTagPtrOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o ResourceLfTagLfTagOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceLfTagLfTag) *string { return v.CatalogId }).(pulumi.StringPtrOutput)
}

// Key name for an existing LF-tag.
func (o ResourceLfTagLfTagOutput) Key() pulumi.StringOutput {
	return o.ApplyT(func(v ResourceLfTagLfTag) string { return v.Key }).(pulumi.StringOutput)
}

// Value from the possible values for the LF-tag.
//
// The following argument is optional:
func (o ResourceLfTagLfTagOutput) Value() pulumi.StringOutput {
	return o.ApplyT(func(v ResourceLfTagLfTag) string { return v.Value }).(pulumi.StringOutput)
}

type ResourceLfTagLfTagPtrOutput struct{ *pulumi.OutputState }

func (ResourceLfTagLfTagPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceLfTagLfTag)(nil)).Elem()
}

func (o ResourceLfTagLfTagPtrOutput) ToResourceLfTagLfTagPtrOutput() ResourceLfTagLfTagPtrOutput {
	return o
}

func (o ResourceLfTagLfTagPtrOutput) ToResourceLfTagLfTagPtrOutputWithContext(ctx context.Context) ResourceLfTagLfTagPtrOutput {
	return o
}

func (o ResourceLfTagLfTagPtrOutput) Elem() ResourceLfTagLfTagOutput {
	return o.ApplyT(func(v *ResourceLfTagLfTag) ResourceLfTagLfTag {
		if v != nil {
			return *v
		}
		var ret ResourceLfTagLfTag
		return ret
	}).(ResourceLfTagLfTagOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o ResourceLfTagLfTagPtrOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceLfTagLfTag) *string {
		if v == nil {
			return nil
		}
		return v.CatalogId
	}).(pulumi.StringPtrOutput)
}

// Key name for an existing LF-tag.
func (o ResourceLfTagLfTagPtrOutput) Key() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceLfTagLfTag) *string {
		if v == nil {
			return nil
		}
		return &v.Key
	}).(pulumi.StringPtrOutput)
}

// Value from the possible values for the LF-tag.
//
// The following argument is optional:
func (o ResourceLfTagLfTagPtrOutput) Value() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceLfTagLfTag) *string {
		if v == nil {
			return nil
		}
		return &v.Value
	}).(pulumi.StringPtrOutput)
}

type ResourceLfTagTable struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId *string `pulumi:"catalogId"`
	// Name of the database for the table. Unique to a Data Catalog.
	DatabaseName string `pulumi:"databaseName"`
	// Name of the table.
	Name *string `pulumi:"name"`
	// Whether to use a wildcard representing every table under a database. Defaults to `false`.
	//
	// The following arguments are optional:
	Wildcard *bool `pulumi:"wildcard"`
}

// ResourceLfTagTableInput is an input type that accepts ResourceLfTagTableArgs and ResourceLfTagTableOutput values.
// You can construct a concrete instance of `ResourceLfTagTableInput` via:
//
//	ResourceLfTagTableArgs{...}
type ResourceLfTagTableInput interface {
	pulumi.Input

	ToResourceLfTagTableOutput() ResourceLfTagTableOutput
	ToResourceLfTagTableOutputWithContext(context.Context) ResourceLfTagTableOutput
}

type ResourceLfTagTableArgs struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId pulumi.StringPtrInput `pulumi:"catalogId"`
	// Name of the database for the table. Unique to a Data Catalog.
	DatabaseName pulumi.StringInput `pulumi:"databaseName"`
	// Name of the table.
	Name pulumi.StringPtrInput `pulumi:"name"`
	// Whether to use a wildcard representing every table under a database. Defaults to `false`.
	//
	// The following arguments are optional:
	Wildcard pulumi.BoolPtrInput `pulumi:"wildcard"`
}

func (ResourceLfTagTableArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceLfTagTable)(nil)).Elem()
}

func (i ResourceLfTagTableArgs) ToResourceLfTagTableOutput() ResourceLfTagTableOutput {
	return i.ToResourceLfTagTableOutputWithContext(context.Background())
}

func (i ResourceLfTagTableArgs) ToResourceLfTagTableOutputWithContext(ctx context.Context) ResourceLfTagTableOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagTableOutput)
}

func (i ResourceLfTagTableArgs) ToResourceLfTagTablePtrOutput() ResourceLfTagTablePtrOutput {
	return i.ToResourceLfTagTablePtrOutputWithContext(context.Background())
}

func (i ResourceLfTagTableArgs) ToResourceLfTagTablePtrOutputWithContext(ctx context.Context) ResourceLfTagTablePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagTableOutput).ToResourceLfTagTablePtrOutputWithContext(ctx)
}

// ResourceLfTagTablePtrInput is an input type that accepts ResourceLfTagTableArgs, ResourceLfTagTablePtr and ResourceLfTagTablePtrOutput values.
// You can construct a concrete instance of `ResourceLfTagTablePtrInput` via:
//
//	        ResourceLfTagTableArgs{...}
//
//	or:
//
//	        nil
type ResourceLfTagTablePtrInput interface {
	pulumi.Input

	ToResourceLfTagTablePtrOutput() ResourceLfTagTablePtrOutput
	ToResourceLfTagTablePtrOutputWithContext(context.Context) ResourceLfTagTablePtrOutput
}

type resourceLfTagTablePtrType ResourceLfTagTableArgs

func ResourceLfTagTablePtr(v *ResourceLfTagTableArgs) ResourceLfTagTablePtrInput {
	return (*resourceLfTagTablePtrType)(v)
}

func (*resourceLfTagTablePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceLfTagTable)(nil)).Elem()
}

func (i *resourceLfTagTablePtrType) ToResourceLfTagTablePtrOutput() ResourceLfTagTablePtrOutput {
	return i.ToResourceLfTagTablePtrOutputWithContext(context.Background())
}

func (i *resourceLfTagTablePtrType) ToResourceLfTagTablePtrOutputWithContext(ctx context.Context) ResourceLfTagTablePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagTablePtrOutput)
}

type ResourceLfTagTableOutput struct{ *pulumi.OutputState }

func (ResourceLfTagTableOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceLfTagTable)(nil)).Elem()
}

func (o ResourceLfTagTableOutput) ToResourceLfTagTableOutput() ResourceLfTagTableOutput {
	return o
}

func (o ResourceLfTagTableOutput) ToResourceLfTagTableOutputWithContext(ctx context.Context) ResourceLfTagTableOutput {
	return o
}

func (o ResourceLfTagTableOutput) ToResourceLfTagTablePtrOutput() ResourceLfTagTablePtrOutput {
	return o.ToResourceLfTagTablePtrOutputWithContext(context.Background())
}

func (o ResourceLfTagTableOutput) ToResourceLfTagTablePtrOutputWithContext(ctx context.Context) ResourceLfTagTablePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ResourceLfTagTable) *ResourceLfTagTable {
		return &v
	}).(ResourceLfTagTablePtrOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o ResourceLfTagTableOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceLfTagTable) *string { return v.CatalogId }).(pulumi.StringPtrOutput)
}

// Name of the database for the table. Unique to a Data Catalog.
func (o ResourceLfTagTableOutput) DatabaseName() pulumi.StringOutput {
	return o.ApplyT(func(v ResourceLfTagTable) string { return v.DatabaseName }).(pulumi.StringOutput)
}

// Name of the table.
func (o ResourceLfTagTableOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceLfTagTable) *string { return v.Name }).(pulumi.StringPtrOutput)
}

// Whether to use a wildcard representing every table under a database. Defaults to `false`.
//
// The following arguments are optional:
func (o ResourceLfTagTableOutput) Wildcard() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v ResourceLfTagTable) *bool { return v.Wildcard }).(pulumi.BoolPtrOutput)
}

type ResourceLfTagTablePtrOutput struct{ *pulumi.OutputState }

func (ResourceLfTagTablePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceLfTagTable)(nil)).Elem()
}

func (o ResourceLfTagTablePtrOutput) ToResourceLfTagTablePtrOutput() ResourceLfTagTablePtrOutput {
	return o
}

func (o ResourceLfTagTablePtrOutput) ToResourceLfTagTablePtrOutputWithContext(ctx context.Context) ResourceLfTagTablePtrOutput {
	return o
}

func (o ResourceLfTagTablePtrOutput) Elem() ResourceLfTagTableOutput {
	return o.ApplyT(func(v *ResourceLfTagTable) ResourceLfTagTable {
		if v != nil {
			return *v
		}
		var ret ResourceLfTagTable
		return ret
	}).(ResourceLfTagTableOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o ResourceLfTagTablePtrOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceLfTagTable) *string {
		if v == nil {
			return nil
		}
		return v.CatalogId
	}).(pulumi.StringPtrOutput)
}

// Name of the database for the table. Unique to a Data Catalog.
func (o ResourceLfTagTablePtrOutput) DatabaseName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceLfTagTable) *string {
		if v == nil {
			return nil
		}
		return &v.DatabaseName
	}).(pulumi.StringPtrOutput)
}

// Name of the table.
func (o ResourceLfTagTablePtrOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceLfTagTable) *string {
		if v == nil {
			return nil
		}
		return v.Name
	}).(pulumi.StringPtrOutput)
}

// Whether to use a wildcard representing every table under a database. Defaults to `false`.
//
// The following arguments are optional:
func (o ResourceLfTagTablePtrOutput) Wildcard() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *ResourceLfTagTable) *bool {
		if v == nil {
			return nil
		}
		return v.Wildcard
	}).(pulumi.BoolPtrOutput)
}

type ResourceLfTagTableWithColumns struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId *string `pulumi:"catalogId"`
	// Set of column names for the table.
	ColumnNames []string `pulumi:"columnNames"`
	// Option to add column wildcard. See Column Wildcard for more details.
	ColumnWildcard *ResourceLfTagTableWithColumnsColumnWildcard `pulumi:"columnWildcard"`
	// Name of the database for the table with columns resource. Unique to the Data Catalog.
	DatabaseName string `pulumi:"databaseName"`
	// Name of the table resource.
	//
	// The following arguments are optional:
	Name string `pulumi:"name"`
}

// ResourceLfTagTableWithColumnsInput is an input type that accepts ResourceLfTagTableWithColumnsArgs and ResourceLfTagTableWithColumnsOutput values.
// You can construct a concrete instance of `ResourceLfTagTableWithColumnsInput` via:
//
//	ResourceLfTagTableWithColumnsArgs{...}
type ResourceLfTagTableWithColumnsInput interface {
	pulumi.Input

	ToResourceLfTagTableWithColumnsOutput() ResourceLfTagTableWithColumnsOutput
	ToResourceLfTagTableWithColumnsOutputWithContext(context.Context) ResourceLfTagTableWithColumnsOutput
}

type ResourceLfTagTableWithColumnsArgs struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId pulumi.StringPtrInput `pulumi:"catalogId"`
	// Set of column names for the table.
	ColumnNames pulumi.StringArrayInput `pulumi:"columnNames"`
	// Option to add column wildcard. See Column Wildcard for more details.
	ColumnWildcard ResourceLfTagTableWithColumnsColumnWildcardPtrInput `pulumi:"columnWildcard"`
	// Name of the database for the table with columns resource. Unique to the Data Catalog.
	DatabaseName pulumi.StringInput `pulumi:"databaseName"`
	// Name of the table resource.
	//
	// The following arguments are optional:
	Name pulumi.StringInput `pulumi:"name"`
}

func (ResourceLfTagTableWithColumnsArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceLfTagTableWithColumns)(nil)).Elem()
}

func (i ResourceLfTagTableWithColumnsArgs) ToResourceLfTagTableWithColumnsOutput() ResourceLfTagTableWithColumnsOutput {
	return i.ToResourceLfTagTableWithColumnsOutputWithContext(context.Background())
}

func (i ResourceLfTagTableWithColumnsArgs) ToResourceLfTagTableWithColumnsOutputWithContext(ctx context.Context) ResourceLfTagTableWithColumnsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagTableWithColumnsOutput)
}

func (i ResourceLfTagTableWithColumnsArgs) ToResourceLfTagTableWithColumnsPtrOutput() ResourceLfTagTableWithColumnsPtrOutput {
	return i.ToResourceLfTagTableWithColumnsPtrOutputWithContext(context.Background())
}

func (i ResourceLfTagTableWithColumnsArgs) ToResourceLfTagTableWithColumnsPtrOutputWithContext(ctx context.Context) ResourceLfTagTableWithColumnsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagTableWithColumnsOutput).ToResourceLfTagTableWithColumnsPtrOutputWithContext(ctx)
}

// ResourceLfTagTableWithColumnsPtrInput is an input type that accepts ResourceLfTagTableWithColumnsArgs, ResourceLfTagTableWithColumnsPtr and ResourceLfTagTableWithColumnsPtrOutput values.
// You can construct a concrete instance of `ResourceLfTagTableWithColumnsPtrInput` via:
//
//	        ResourceLfTagTableWithColumnsArgs{...}
//
//	or:
//
//	        nil
type ResourceLfTagTableWithColumnsPtrInput interface {
	pulumi.Input

	ToResourceLfTagTableWithColumnsPtrOutput() ResourceLfTagTableWithColumnsPtrOutput
	ToResourceLfTagTableWithColumnsPtrOutputWithContext(context.Context) ResourceLfTagTableWithColumnsPtrOutput
}

type resourceLfTagTableWithColumnsPtrType ResourceLfTagTableWithColumnsArgs

func ResourceLfTagTableWithColumnsPtr(v *ResourceLfTagTableWithColumnsArgs) ResourceLfTagTableWithColumnsPtrInput {
	return (*resourceLfTagTableWithColumnsPtrType)(v)
}

func (*resourceLfTagTableWithColumnsPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceLfTagTableWithColumns)(nil)).Elem()
}

func (i *resourceLfTagTableWithColumnsPtrType) ToResourceLfTagTableWithColumnsPtrOutput() ResourceLfTagTableWithColumnsPtrOutput {
	return i.ToResourceLfTagTableWithColumnsPtrOutputWithContext(context.Background())
}

func (i *resourceLfTagTableWithColumnsPtrType) ToResourceLfTagTableWithColumnsPtrOutputWithContext(ctx context.Context) ResourceLfTagTableWithColumnsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagTableWithColumnsPtrOutput)
}

type ResourceLfTagTableWithColumnsOutput struct{ *pulumi.OutputState }

func (ResourceLfTagTableWithColumnsOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceLfTagTableWithColumns)(nil)).Elem()
}

func (o ResourceLfTagTableWithColumnsOutput) ToResourceLfTagTableWithColumnsOutput() ResourceLfTagTableWithColumnsOutput {
	return o
}

func (o ResourceLfTagTableWithColumnsOutput) ToResourceLfTagTableWithColumnsOutputWithContext(ctx context.Context) ResourceLfTagTableWithColumnsOutput {
	return o
}

func (o ResourceLfTagTableWithColumnsOutput) ToResourceLfTagTableWithColumnsPtrOutput() ResourceLfTagTableWithColumnsPtrOutput {
	return o.ToResourceLfTagTableWithColumnsPtrOutputWithContext(context.Background())
}

func (o ResourceLfTagTableWithColumnsOutput) ToResourceLfTagTableWithColumnsPtrOutputWithContext(ctx context.Context) ResourceLfTagTableWithColumnsPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ResourceLfTagTableWithColumns) *ResourceLfTagTableWithColumns {
		return &v
	}).(ResourceLfTagTableWithColumnsPtrOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o ResourceLfTagTableWithColumnsOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceLfTagTableWithColumns) *string { return v.CatalogId }).(pulumi.StringPtrOutput)
}

// Set of column names for the table.
func (o ResourceLfTagTableWithColumnsOutput) ColumnNames() pulumi.StringArrayOutput {
	return o.ApplyT(func(v ResourceLfTagTableWithColumns) []string { return v.ColumnNames }).(pulumi.StringArrayOutput)
}

// Option to add column wildcard. See Column Wildcard for more details.
func (o ResourceLfTagTableWithColumnsOutput) ColumnWildcard() ResourceLfTagTableWithColumnsColumnWildcardPtrOutput {
	return o.ApplyT(func(v ResourceLfTagTableWithColumns) *ResourceLfTagTableWithColumnsColumnWildcard {
		return v.ColumnWildcard
	}).(ResourceLfTagTableWithColumnsColumnWildcardPtrOutput)
}

// Name of the database for the table with columns resource. Unique to the Data Catalog.
func (o ResourceLfTagTableWithColumnsOutput) DatabaseName() pulumi.StringOutput {
	return o.ApplyT(func(v ResourceLfTagTableWithColumns) string { return v.DatabaseName }).(pulumi.StringOutput)
}

// Name of the table resource.
//
// The following arguments are optional:
func (o ResourceLfTagTableWithColumnsOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v ResourceLfTagTableWithColumns) string { return v.Name }).(pulumi.StringOutput)
}

type ResourceLfTagTableWithColumnsPtrOutput struct{ *pulumi.OutputState }

func (ResourceLfTagTableWithColumnsPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceLfTagTableWithColumns)(nil)).Elem()
}

func (o ResourceLfTagTableWithColumnsPtrOutput) ToResourceLfTagTableWithColumnsPtrOutput() ResourceLfTagTableWithColumnsPtrOutput {
	return o
}

func (o ResourceLfTagTableWithColumnsPtrOutput) ToResourceLfTagTableWithColumnsPtrOutputWithContext(ctx context.Context) ResourceLfTagTableWithColumnsPtrOutput {
	return o
}

func (o ResourceLfTagTableWithColumnsPtrOutput) Elem() ResourceLfTagTableWithColumnsOutput {
	return o.ApplyT(func(v *ResourceLfTagTableWithColumns) ResourceLfTagTableWithColumns {
		if v != nil {
			return *v
		}
		var ret ResourceLfTagTableWithColumns
		return ret
	}).(ResourceLfTagTableWithColumnsOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o ResourceLfTagTableWithColumnsPtrOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceLfTagTableWithColumns) *string {
		if v == nil {
			return nil
		}
		return v.CatalogId
	}).(pulumi.StringPtrOutput)
}

// Set of column names for the table.
func (o ResourceLfTagTableWithColumnsPtrOutput) ColumnNames() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *ResourceLfTagTableWithColumns) []string {
		if v == nil {
			return nil
		}
		return v.ColumnNames
	}).(pulumi.StringArrayOutput)
}

// Option to add column wildcard. See Column Wildcard for more details.
func (o ResourceLfTagTableWithColumnsPtrOutput) ColumnWildcard() ResourceLfTagTableWithColumnsColumnWildcardPtrOutput {
	return o.ApplyT(func(v *ResourceLfTagTableWithColumns) *ResourceLfTagTableWithColumnsColumnWildcard {
		if v == nil {
			return nil
		}
		return v.ColumnWildcard
	}).(ResourceLfTagTableWithColumnsColumnWildcardPtrOutput)
}

// Name of the database for the table with columns resource. Unique to the Data Catalog.
func (o ResourceLfTagTableWithColumnsPtrOutput) DatabaseName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceLfTagTableWithColumns) *string {
		if v == nil {
			return nil
		}
		return &v.DatabaseName
	}).(pulumi.StringPtrOutput)
}

// Name of the table resource.
//
// The following arguments are optional:
func (o ResourceLfTagTableWithColumnsPtrOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceLfTagTableWithColumns) *string {
		if v == nil {
			return nil
		}
		return &v.Name
	}).(pulumi.StringPtrOutput)
}

type ResourceLfTagTableWithColumnsColumnWildcard struct {
	ExcludedColumnNames []string `pulumi:"excludedColumnNames"`
}

// ResourceLfTagTableWithColumnsColumnWildcardInput is an input type that accepts ResourceLfTagTableWithColumnsColumnWildcardArgs and ResourceLfTagTableWithColumnsColumnWildcardOutput values.
// You can construct a concrete instance of `ResourceLfTagTableWithColumnsColumnWildcardInput` via:
//
//	ResourceLfTagTableWithColumnsColumnWildcardArgs{...}
type ResourceLfTagTableWithColumnsColumnWildcardInput interface {
	pulumi.Input

	ToResourceLfTagTableWithColumnsColumnWildcardOutput() ResourceLfTagTableWithColumnsColumnWildcardOutput
	ToResourceLfTagTableWithColumnsColumnWildcardOutputWithContext(context.Context) ResourceLfTagTableWithColumnsColumnWildcardOutput
}

type ResourceLfTagTableWithColumnsColumnWildcardArgs struct {
	ExcludedColumnNames pulumi.StringArrayInput `pulumi:"excludedColumnNames"`
}

func (ResourceLfTagTableWithColumnsColumnWildcardArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceLfTagTableWithColumnsColumnWildcard)(nil)).Elem()
}

func (i ResourceLfTagTableWithColumnsColumnWildcardArgs) ToResourceLfTagTableWithColumnsColumnWildcardOutput() ResourceLfTagTableWithColumnsColumnWildcardOutput {
	return i.ToResourceLfTagTableWithColumnsColumnWildcardOutputWithContext(context.Background())
}

func (i ResourceLfTagTableWithColumnsColumnWildcardArgs) ToResourceLfTagTableWithColumnsColumnWildcardOutputWithContext(ctx context.Context) ResourceLfTagTableWithColumnsColumnWildcardOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagTableWithColumnsColumnWildcardOutput)
}

func (i ResourceLfTagTableWithColumnsColumnWildcardArgs) ToResourceLfTagTableWithColumnsColumnWildcardPtrOutput() ResourceLfTagTableWithColumnsColumnWildcardPtrOutput {
	return i.ToResourceLfTagTableWithColumnsColumnWildcardPtrOutputWithContext(context.Background())
}

func (i ResourceLfTagTableWithColumnsColumnWildcardArgs) ToResourceLfTagTableWithColumnsColumnWildcardPtrOutputWithContext(ctx context.Context) ResourceLfTagTableWithColumnsColumnWildcardPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagTableWithColumnsColumnWildcardOutput).ToResourceLfTagTableWithColumnsColumnWildcardPtrOutputWithContext(ctx)
}

// ResourceLfTagTableWithColumnsColumnWildcardPtrInput is an input type that accepts ResourceLfTagTableWithColumnsColumnWildcardArgs, ResourceLfTagTableWithColumnsColumnWildcardPtr and ResourceLfTagTableWithColumnsColumnWildcardPtrOutput values.
// You can construct a concrete instance of `ResourceLfTagTableWithColumnsColumnWildcardPtrInput` via:
//
//	        ResourceLfTagTableWithColumnsColumnWildcardArgs{...}
//
//	or:
//
//	        nil
type ResourceLfTagTableWithColumnsColumnWildcardPtrInput interface {
	pulumi.Input

	ToResourceLfTagTableWithColumnsColumnWildcardPtrOutput() ResourceLfTagTableWithColumnsColumnWildcardPtrOutput
	ToResourceLfTagTableWithColumnsColumnWildcardPtrOutputWithContext(context.Context) ResourceLfTagTableWithColumnsColumnWildcardPtrOutput
}

type resourceLfTagTableWithColumnsColumnWildcardPtrType ResourceLfTagTableWithColumnsColumnWildcardArgs

func ResourceLfTagTableWithColumnsColumnWildcardPtr(v *ResourceLfTagTableWithColumnsColumnWildcardArgs) ResourceLfTagTableWithColumnsColumnWildcardPtrInput {
	return (*resourceLfTagTableWithColumnsColumnWildcardPtrType)(v)
}

func (*resourceLfTagTableWithColumnsColumnWildcardPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceLfTagTableWithColumnsColumnWildcard)(nil)).Elem()
}

func (i *resourceLfTagTableWithColumnsColumnWildcardPtrType) ToResourceLfTagTableWithColumnsColumnWildcardPtrOutput() ResourceLfTagTableWithColumnsColumnWildcardPtrOutput {
	return i.ToResourceLfTagTableWithColumnsColumnWildcardPtrOutputWithContext(context.Background())
}

func (i *resourceLfTagTableWithColumnsColumnWildcardPtrType) ToResourceLfTagTableWithColumnsColumnWildcardPtrOutputWithContext(ctx context.Context) ResourceLfTagTableWithColumnsColumnWildcardPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagTableWithColumnsColumnWildcardPtrOutput)
}

type ResourceLfTagTableWithColumnsColumnWildcardOutput struct{ *pulumi.OutputState }

func (ResourceLfTagTableWithColumnsColumnWildcardOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceLfTagTableWithColumnsColumnWildcard)(nil)).Elem()
}

func (o ResourceLfTagTableWithColumnsColumnWildcardOutput) ToResourceLfTagTableWithColumnsColumnWildcardOutput() ResourceLfTagTableWithColumnsColumnWildcardOutput {
	return o
}

func (o ResourceLfTagTableWithColumnsColumnWildcardOutput) ToResourceLfTagTableWithColumnsColumnWildcardOutputWithContext(ctx context.Context) ResourceLfTagTableWithColumnsColumnWildcardOutput {
	return o
}

func (o ResourceLfTagTableWithColumnsColumnWildcardOutput) ToResourceLfTagTableWithColumnsColumnWildcardPtrOutput() ResourceLfTagTableWithColumnsColumnWildcardPtrOutput {
	return o.ToResourceLfTagTableWithColumnsColumnWildcardPtrOutputWithContext(context.Background())
}

func (o ResourceLfTagTableWithColumnsColumnWildcardOutput) ToResourceLfTagTableWithColumnsColumnWildcardPtrOutputWithContext(ctx context.Context) ResourceLfTagTableWithColumnsColumnWildcardPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ResourceLfTagTableWithColumnsColumnWildcard) *ResourceLfTagTableWithColumnsColumnWildcard {
		return &v
	}).(ResourceLfTagTableWithColumnsColumnWildcardPtrOutput)
}

func (o ResourceLfTagTableWithColumnsColumnWildcardOutput) ExcludedColumnNames() pulumi.StringArrayOutput {
	return o.ApplyT(func(v ResourceLfTagTableWithColumnsColumnWildcard) []string { return v.ExcludedColumnNames }).(pulumi.StringArrayOutput)
}

type ResourceLfTagTableWithColumnsColumnWildcardPtrOutput struct{ *pulumi.OutputState }

func (ResourceLfTagTableWithColumnsColumnWildcardPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceLfTagTableWithColumnsColumnWildcard)(nil)).Elem()
}

func (o ResourceLfTagTableWithColumnsColumnWildcardPtrOutput) ToResourceLfTagTableWithColumnsColumnWildcardPtrOutput() ResourceLfTagTableWithColumnsColumnWildcardPtrOutput {
	return o
}

func (o ResourceLfTagTableWithColumnsColumnWildcardPtrOutput) ToResourceLfTagTableWithColumnsColumnWildcardPtrOutputWithContext(ctx context.Context) ResourceLfTagTableWithColumnsColumnWildcardPtrOutput {
	return o
}

func (o ResourceLfTagTableWithColumnsColumnWildcardPtrOutput) Elem() ResourceLfTagTableWithColumnsColumnWildcardOutput {
	return o.ApplyT(func(v *ResourceLfTagTableWithColumnsColumnWildcard) ResourceLfTagTableWithColumnsColumnWildcard {
		if v != nil {
			return *v
		}
		var ret ResourceLfTagTableWithColumnsColumnWildcard
		return ret
	}).(ResourceLfTagTableWithColumnsColumnWildcardOutput)
}

func (o ResourceLfTagTableWithColumnsColumnWildcardPtrOutput) ExcludedColumnNames() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *ResourceLfTagTableWithColumnsColumnWildcard) []string {
		if v == nil {
			return nil
		}
		return v.ExcludedColumnNames
	}).(pulumi.StringArrayOutput)
}

type ResourceLfTagTimeouts struct {
	// A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
	Create *string `pulumi:"create"`
	// A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
	Delete *string `pulumi:"delete"`
}

// ResourceLfTagTimeoutsInput is an input type that accepts ResourceLfTagTimeoutsArgs and ResourceLfTagTimeoutsOutput values.
// You can construct a concrete instance of `ResourceLfTagTimeoutsInput` via:
//
//	ResourceLfTagTimeoutsArgs{...}
type ResourceLfTagTimeoutsInput interface {
	pulumi.Input

	ToResourceLfTagTimeoutsOutput() ResourceLfTagTimeoutsOutput
	ToResourceLfTagTimeoutsOutputWithContext(context.Context) ResourceLfTagTimeoutsOutput
}

type ResourceLfTagTimeoutsArgs struct {
	// A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
	Create pulumi.StringPtrInput `pulumi:"create"`
	// A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
	Delete pulumi.StringPtrInput `pulumi:"delete"`
}

func (ResourceLfTagTimeoutsArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceLfTagTimeouts)(nil)).Elem()
}

func (i ResourceLfTagTimeoutsArgs) ToResourceLfTagTimeoutsOutput() ResourceLfTagTimeoutsOutput {
	return i.ToResourceLfTagTimeoutsOutputWithContext(context.Background())
}

func (i ResourceLfTagTimeoutsArgs) ToResourceLfTagTimeoutsOutputWithContext(ctx context.Context) ResourceLfTagTimeoutsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagTimeoutsOutput)
}

func (i ResourceLfTagTimeoutsArgs) ToResourceLfTagTimeoutsPtrOutput() ResourceLfTagTimeoutsPtrOutput {
	return i.ToResourceLfTagTimeoutsPtrOutputWithContext(context.Background())
}

func (i ResourceLfTagTimeoutsArgs) ToResourceLfTagTimeoutsPtrOutputWithContext(ctx context.Context) ResourceLfTagTimeoutsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagTimeoutsOutput).ToResourceLfTagTimeoutsPtrOutputWithContext(ctx)
}

// ResourceLfTagTimeoutsPtrInput is an input type that accepts ResourceLfTagTimeoutsArgs, ResourceLfTagTimeoutsPtr and ResourceLfTagTimeoutsPtrOutput values.
// You can construct a concrete instance of `ResourceLfTagTimeoutsPtrInput` via:
//
//	        ResourceLfTagTimeoutsArgs{...}
//
//	or:
//
//	        nil
type ResourceLfTagTimeoutsPtrInput interface {
	pulumi.Input

	ToResourceLfTagTimeoutsPtrOutput() ResourceLfTagTimeoutsPtrOutput
	ToResourceLfTagTimeoutsPtrOutputWithContext(context.Context) ResourceLfTagTimeoutsPtrOutput
}

type resourceLfTagTimeoutsPtrType ResourceLfTagTimeoutsArgs

func ResourceLfTagTimeoutsPtr(v *ResourceLfTagTimeoutsArgs) ResourceLfTagTimeoutsPtrInput {
	return (*resourceLfTagTimeoutsPtrType)(v)
}

func (*resourceLfTagTimeoutsPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceLfTagTimeouts)(nil)).Elem()
}

func (i *resourceLfTagTimeoutsPtrType) ToResourceLfTagTimeoutsPtrOutput() ResourceLfTagTimeoutsPtrOutput {
	return i.ToResourceLfTagTimeoutsPtrOutputWithContext(context.Background())
}

func (i *resourceLfTagTimeoutsPtrType) ToResourceLfTagTimeoutsPtrOutputWithContext(ctx context.Context) ResourceLfTagTimeoutsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagTimeoutsPtrOutput)
}

type ResourceLfTagTimeoutsOutput struct{ *pulumi.OutputState }

func (ResourceLfTagTimeoutsOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceLfTagTimeouts)(nil)).Elem()
}

func (o ResourceLfTagTimeoutsOutput) ToResourceLfTagTimeoutsOutput() ResourceLfTagTimeoutsOutput {
	return o
}

func (o ResourceLfTagTimeoutsOutput) ToResourceLfTagTimeoutsOutputWithContext(ctx context.Context) ResourceLfTagTimeoutsOutput {
	return o
}

func (o ResourceLfTagTimeoutsOutput) ToResourceLfTagTimeoutsPtrOutput() ResourceLfTagTimeoutsPtrOutput {
	return o.ToResourceLfTagTimeoutsPtrOutputWithContext(context.Background())
}

func (o ResourceLfTagTimeoutsOutput) ToResourceLfTagTimeoutsPtrOutputWithContext(ctx context.Context) ResourceLfTagTimeoutsPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ResourceLfTagTimeouts) *ResourceLfTagTimeouts {
		return &v
	}).(ResourceLfTagTimeoutsPtrOutput)
}

// A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
func (o ResourceLfTagTimeoutsOutput) Create() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceLfTagTimeouts) *string { return v.Create }).(pulumi.StringPtrOutput)
}

// A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
func (o ResourceLfTagTimeoutsOutput) Delete() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceLfTagTimeouts) *string { return v.Delete }).(pulumi.StringPtrOutput)
}

type ResourceLfTagTimeoutsPtrOutput struct{ *pulumi.OutputState }

func (ResourceLfTagTimeoutsPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceLfTagTimeouts)(nil)).Elem()
}

func (o ResourceLfTagTimeoutsPtrOutput) ToResourceLfTagTimeoutsPtrOutput() ResourceLfTagTimeoutsPtrOutput {
	return o
}

func (o ResourceLfTagTimeoutsPtrOutput) ToResourceLfTagTimeoutsPtrOutputWithContext(ctx context.Context) ResourceLfTagTimeoutsPtrOutput {
	return o
}

func (o ResourceLfTagTimeoutsPtrOutput) Elem() ResourceLfTagTimeoutsOutput {
	return o.ApplyT(func(v *ResourceLfTagTimeouts) ResourceLfTagTimeouts {
		if v != nil {
			return *v
		}
		var ret ResourceLfTagTimeouts
		return ret
	}).(ResourceLfTagTimeoutsOutput)
}

// A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
func (o ResourceLfTagTimeoutsPtrOutput) Create() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceLfTagTimeouts) *string {
		if v == nil {
			return nil
		}
		return v.Create
	}).(pulumi.StringPtrOutput)
}

// A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
func (o ResourceLfTagTimeoutsPtrOutput) Delete() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceLfTagTimeouts) *string {
		if v == nil {
			return nil
		}
		return v.Delete
	}).(pulumi.StringPtrOutput)
}

type ResourceLfTagsDatabase struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId *string `pulumi:"catalogId"`
	// Name of the database resource. Unique to the Data Catalog.
	//
	// The following argument is optional:
	Name string `pulumi:"name"`
}

// ResourceLfTagsDatabaseInput is an input type that accepts ResourceLfTagsDatabaseArgs and ResourceLfTagsDatabaseOutput values.
// You can construct a concrete instance of `ResourceLfTagsDatabaseInput` via:
//
//	ResourceLfTagsDatabaseArgs{...}
type ResourceLfTagsDatabaseInput interface {
	pulumi.Input

	ToResourceLfTagsDatabaseOutput() ResourceLfTagsDatabaseOutput
	ToResourceLfTagsDatabaseOutputWithContext(context.Context) ResourceLfTagsDatabaseOutput
}

type ResourceLfTagsDatabaseArgs struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId pulumi.StringPtrInput `pulumi:"catalogId"`
	// Name of the database resource. Unique to the Data Catalog.
	//
	// The following argument is optional:
	Name pulumi.StringInput `pulumi:"name"`
}

func (ResourceLfTagsDatabaseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceLfTagsDatabase)(nil)).Elem()
}

func (i ResourceLfTagsDatabaseArgs) ToResourceLfTagsDatabaseOutput() ResourceLfTagsDatabaseOutput {
	return i.ToResourceLfTagsDatabaseOutputWithContext(context.Background())
}

func (i ResourceLfTagsDatabaseArgs) ToResourceLfTagsDatabaseOutputWithContext(ctx context.Context) ResourceLfTagsDatabaseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagsDatabaseOutput)
}

func (i ResourceLfTagsDatabaseArgs) ToResourceLfTagsDatabasePtrOutput() ResourceLfTagsDatabasePtrOutput {
	return i.ToResourceLfTagsDatabasePtrOutputWithContext(context.Background())
}

func (i ResourceLfTagsDatabaseArgs) ToResourceLfTagsDatabasePtrOutputWithContext(ctx context.Context) ResourceLfTagsDatabasePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagsDatabaseOutput).ToResourceLfTagsDatabasePtrOutputWithContext(ctx)
}

// ResourceLfTagsDatabasePtrInput is an input type that accepts ResourceLfTagsDatabaseArgs, ResourceLfTagsDatabasePtr and ResourceLfTagsDatabasePtrOutput values.
// You can construct a concrete instance of `ResourceLfTagsDatabasePtrInput` via:
//
//	        ResourceLfTagsDatabaseArgs{...}
//
//	or:
//
//	        nil
type ResourceLfTagsDatabasePtrInput interface {
	pulumi.Input

	ToResourceLfTagsDatabasePtrOutput() ResourceLfTagsDatabasePtrOutput
	ToResourceLfTagsDatabasePtrOutputWithContext(context.Context) ResourceLfTagsDatabasePtrOutput
}

type resourceLfTagsDatabasePtrType ResourceLfTagsDatabaseArgs

func ResourceLfTagsDatabasePtr(v *ResourceLfTagsDatabaseArgs) ResourceLfTagsDatabasePtrInput {
	return (*resourceLfTagsDatabasePtrType)(v)
}

func (*resourceLfTagsDatabasePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceLfTagsDatabase)(nil)).Elem()
}

func (i *resourceLfTagsDatabasePtrType) ToResourceLfTagsDatabasePtrOutput() ResourceLfTagsDatabasePtrOutput {
	return i.ToResourceLfTagsDatabasePtrOutputWithContext(context.Background())
}

func (i *resourceLfTagsDatabasePtrType) ToResourceLfTagsDatabasePtrOutputWithContext(ctx context.Context) ResourceLfTagsDatabasePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagsDatabasePtrOutput)
}

type ResourceLfTagsDatabaseOutput struct{ *pulumi.OutputState }

func (ResourceLfTagsDatabaseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceLfTagsDatabase)(nil)).Elem()
}

func (o ResourceLfTagsDatabaseOutput) ToResourceLfTagsDatabaseOutput() ResourceLfTagsDatabaseOutput {
	return o
}

func (o ResourceLfTagsDatabaseOutput) ToResourceLfTagsDatabaseOutputWithContext(ctx context.Context) ResourceLfTagsDatabaseOutput {
	return o
}

func (o ResourceLfTagsDatabaseOutput) ToResourceLfTagsDatabasePtrOutput() ResourceLfTagsDatabasePtrOutput {
	return o.ToResourceLfTagsDatabasePtrOutputWithContext(context.Background())
}

func (o ResourceLfTagsDatabaseOutput) ToResourceLfTagsDatabasePtrOutputWithContext(ctx context.Context) ResourceLfTagsDatabasePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ResourceLfTagsDatabase) *ResourceLfTagsDatabase {
		return &v
	}).(ResourceLfTagsDatabasePtrOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o ResourceLfTagsDatabaseOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceLfTagsDatabase) *string { return v.CatalogId }).(pulumi.StringPtrOutput)
}

// Name of the database resource. Unique to the Data Catalog.
//
// The following argument is optional:
func (o ResourceLfTagsDatabaseOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v ResourceLfTagsDatabase) string { return v.Name }).(pulumi.StringOutput)
}

type ResourceLfTagsDatabasePtrOutput struct{ *pulumi.OutputState }

func (ResourceLfTagsDatabasePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceLfTagsDatabase)(nil)).Elem()
}

func (o ResourceLfTagsDatabasePtrOutput) ToResourceLfTagsDatabasePtrOutput() ResourceLfTagsDatabasePtrOutput {
	return o
}

func (o ResourceLfTagsDatabasePtrOutput) ToResourceLfTagsDatabasePtrOutputWithContext(ctx context.Context) ResourceLfTagsDatabasePtrOutput {
	return o
}

func (o ResourceLfTagsDatabasePtrOutput) Elem() ResourceLfTagsDatabaseOutput {
	return o.ApplyT(func(v *ResourceLfTagsDatabase) ResourceLfTagsDatabase {
		if v != nil {
			return *v
		}
		var ret ResourceLfTagsDatabase
		return ret
	}).(ResourceLfTagsDatabaseOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o ResourceLfTagsDatabasePtrOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceLfTagsDatabase) *string {
		if v == nil {
			return nil
		}
		return v.CatalogId
	}).(pulumi.StringPtrOutput)
}

// Name of the database resource. Unique to the Data Catalog.
//
// The following argument is optional:
func (o ResourceLfTagsDatabasePtrOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceLfTagsDatabase) *string {
		if v == nil {
			return nil
		}
		return &v.Name
	}).(pulumi.StringPtrOutput)
}

type ResourceLfTagsLfTag struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId *string `pulumi:"catalogId"`
	// Key name for an existing LF-tag.
	Key string `pulumi:"key"`
	// Value from the possible values for the LF-tag.
	//
	// The following argument is optional:
	Value string `pulumi:"value"`
}

// ResourceLfTagsLfTagInput is an input type that accepts ResourceLfTagsLfTagArgs and ResourceLfTagsLfTagOutput values.
// You can construct a concrete instance of `ResourceLfTagsLfTagInput` via:
//
//	ResourceLfTagsLfTagArgs{...}
type ResourceLfTagsLfTagInput interface {
	pulumi.Input

	ToResourceLfTagsLfTagOutput() ResourceLfTagsLfTagOutput
	ToResourceLfTagsLfTagOutputWithContext(context.Context) ResourceLfTagsLfTagOutput
}

type ResourceLfTagsLfTagArgs struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId pulumi.StringPtrInput `pulumi:"catalogId"`
	// Key name for an existing LF-tag.
	Key pulumi.StringInput `pulumi:"key"`
	// Value from the possible values for the LF-tag.
	//
	// The following argument is optional:
	Value pulumi.StringInput `pulumi:"value"`
}

func (ResourceLfTagsLfTagArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceLfTagsLfTag)(nil)).Elem()
}

func (i ResourceLfTagsLfTagArgs) ToResourceLfTagsLfTagOutput() ResourceLfTagsLfTagOutput {
	return i.ToResourceLfTagsLfTagOutputWithContext(context.Background())
}

func (i ResourceLfTagsLfTagArgs) ToResourceLfTagsLfTagOutputWithContext(ctx context.Context) ResourceLfTagsLfTagOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagsLfTagOutput)
}

// ResourceLfTagsLfTagArrayInput is an input type that accepts ResourceLfTagsLfTagArray and ResourceLfTagsLfTagArrayOutput values.
// You can construct a concrete instance of `ResourceLfTagsLfTagArrayInput` via:
//
//	ResourceLfTagsLfTagArray{ ResourceLfTagsLfTagArgs{...} }
type ResourceLfTagsLfTagArrayInput interface {
	pulumi.Input

	ToResourceLfTagsLfTagArrayOutput() ResourceLfTagsLfTagArrayOutput
	ToResourceLfTagsLfTagArrayOutputWithContext(context.Context) ResourceLfTagsLfTagArrayOutput
}

type ResourceLfTagsLfTagArray []ResourceLfTagsLfTagInput

func (ResourceLfTagsLfTagArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]ResourceLfTagsLfTag)(nil)).Elem()
}

func (i ResourceLfTagsLfTagArray) ToResourceLfTagsLfTagArrayOutput() ResourceLfTagsLfTagArrayOutput {
	return i.ToResourceLfTagsLfTagArrayOutputWithContext(context.Background())
}

func (i ResourceLfTagsLfTagArray) ToResourceLfTagsLfTagArrayOutputWithContext(ctx context.Context) ResourceLfTagsLfTagArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagsLfTagArrayOutput)
}

type ResourceLfTagsLfTagOutput struct{ *pulumi.OutputState }

func (ResourceLfTagsLfTagOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceLfTagsLfTag)(nil)).Elem()
}

func (o ResourceLfTagsLfTagOutput) ToResourceLfTagsLfTagOutput() ResourceLfTagsLfTagOutput {
	return o
}

func (o ResourceLfTagsLfTagOutput) ToResourceLfTagsLfTagOutputWithContext(ctx context.Context) ResourceLfTagsLfTagOutput {
	return o
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o ResourceLfTagsLfTagOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceLfTagsLfTag) *string { return v.CatalogId }).(pulumi.StringPtrOutput)
}

// Key name for an existing LF-tag.
func (o ResourceLfTagsLfTagOutput) Key() pulumi.StringOutput {
	return o.ApplyT(func(v ResourceLfTagsLfTag) string { return v.Key }).(pulumi.StringOutput)
}

// Value from the possible values for the LF-tag.
//
// The following argument is optional:
func (o ResourceLfTagsLfTagOutput) Value() pulumi.StringOutput {
	return o.ApplyT(func(v ResourceLfTagsLfTag) string { return v.Value }).(pulumi.StringOutput)
}

type ResourceLfTagsLfTagArrayOutput struct{ *pulumi.OutputState }

func (ResourceLfTagsLfTagArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]ResourceLfTagsLfTag)(nil)).Elem()
}

func (o ResourceLfTagsLfTagArrayOutput) ToResourceLfTagsLfTagArrayOutput() ResourceLfTagsLfTagArrayOutput {
	return o
}

func (o ResourceLfTagsLfTagArrayOutput) ToResourceLfTagsLfTagArrayOutputWithContext(ctx context.Context) ResourceLfTagsLfTagArrayOutput {
	return o
}

func (o ResourceLfTagsLfTagArrayOutput) Index(i pulumi.IntInput) ResourceLfTagsLfTagOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) ResourceLfTagsLfTag {
		return vs[0].([]ResourceLfTagsLfTag)[vs[1].(int)]
	}).(ResourceLfTagsLfTagOutput)
}

type ResourceLfTagsTable struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId *string `pulumi:"catalogId"`
	// Name of the database for the table. Unique to a Data Catalog.
	DatabaseName string `pulumi:"databaseName"`
	// Name of the table.
	Name *string `pulumi:"name"`
	// Whether to use a wildcard representing every table under a database. Defaults to `false`.
	//
	// The following arguments are optional:
	Wildcard *bool `pulumi:"wildcard"`
}

// ResourceLfTagsTableInput is an input type that accepts ResourceLfTagsTableArgs and ResourceLfTagsTableOutput values.
// You can construct a concrete instance of `ResourceLfTagsTableInput` via:
//
//	ResourceLfTagsTableArgs{...}
type ResourceLfTagsTableInput interface {
	pulumi.Input

	ToResourceLfTagsTableOutput() ResourceLfTagsTableOutput
	ToResourceLfTagsTableOutputWithContext(context.Context) ResourceLfTagsTableOutput
}

type ResourceLfTagsTableArgs struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId pulumi.StringPtrInput `pulumi:"catalogId"`
	// Name of the database for the table. Unique to a Data Catalog.
	DatabaseName pulumi.StringInput `pulumi:"databaseName"`
	// Name of the table.
	Name pulumi.StringPtrInput `pulumi:"name"`
	// Whether to use a wildcard representing every table under a database. Defaults to `false`.
	//
	// The following arguments are optional:
	Wildcard pulumi.BoolPtrInput `pulumi:"wildcard"`
}

func (ResourceLfTagsTableArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceLfTagsTable)(nil)).Elem()
}

func (i ResourceLfTagsTableArgs) ToResourceLfTagsTableOutput() ResourceLfTagsTableOutput {
	return i.ToResourceLfTagsTableOutputWithContext(context.Background())
}

func (i ResourceLfTagsTableArgs) ToResourceLfTagsTableOutputWithContext(ctx context.Context) ResourceLfTagsTableOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagsTableOutput)
}

func (i ResourceLfTagsTableArgs) ToResourceLfTagsTablePtrOutput() ResourceLfTagsTablePtrOutput {
	return i.ToResourceLfTagsTablePtrOutputWithContext(context.Background())
}

func (i ResourceLfTagsTableArgs) ToResourceLfTagsTablePtrOutputWithContext(ctx context.Context) ResourceLfTagsTablePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagsTableOutput).ToResourceLfTagsTablePtrOutputWithContext(ctx)
}

// ResourceLfTagsTablePtrInput is an input type that accepts ResourceLfTagsTableArgs, ResourceLfTagsTablePtr and ResourceLfTagsTablePtrOutput values.
// You can construct a concrete instance of `ResourceLfTagsTablePtrInput` via:
//
//	        ResourceLfTagsTableArgs{...}
//
//	or:
//
//	        nil
type ResourceLfTagsTablePtrInput interface {
	pulumi.Input

	ToResourceLfTagsTablePtrOutput() ResourceLfTagsTablePtrOutput
	ToResourceLfTagsTablePtrOutputWithContext(context.Context) ResourceLfTagsTablePtrOutput
}

type resourceLfTagsTablePtrType ResourceLfTagsTableArgs

func ResourceLfTagsTablePtr(v *ResourceLfTagsTableArgs) ResourceLfTagsTablePtrInput {
	return (*resourceLfTagsTablePtrType)(v)
}

func (*resourceLfTagsTablePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceLfTagsTable)(nil)).Elem()
}

func (i *resourceLfTagsTablePtrType) ToResourceLfTagsTablePtrOutput() ResourceLfTagsTablePtrOutput {
	return i.ToResourceLfTagsTablePtrOutputWithContext(context.Background())
}

func (i *resourceLfTagsTablePtrType) ToResourceLfTagsTablePtrOutputWithContext(ctx context.Context) ResourceLfTagsTablePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagsTablePtrOutput)
}

type ResourceLfTagsTableOutput struct{ *pulumi.OutputState }

func (ResourceLfTagsTableOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceLfTagsTable)(nil)).Elem()
}

func (o ResourceLfTagsTableOutput) ToResourceLfTagsTableOutput() ResourceLfTagsTableOutput {
	return o
}

func (o ResourceLfTagsTableOutput) ToResourceLfTagsTableOutputWithContext(ctx context.Context) ResourceLfTagsTableOutput {
	return o
}

func (o ResourceLfTagsTableOutput) ToResourceLfTagsTablePtrOutput() ResourceLfTagsTablePtrOutput {
	return o.ToResourceLfTagsTablePtrOutputWithContext(context.Background())
}

func (o ResourceLfTagsTableOutput) ToResourceLfTagsTablePtrOutputWithContext(ctx context.Context) ResourceLfTagsTablePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ResourceLfTagsTable) *ResourceLfTagsTable {
		return &v
	}).(ResourceLfTagsTablePtrOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o ResourceLfTagsTableOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceLfTagsTable) *string { return v.CatalogId }).(pulumi.StringPtrOutput)
}

// Name of the database for the table. Unique to a Data Catalog.
func (o ResourceLfTagsTableOutput) DatabaseName() pulumi.StringOutput {
	return o.ApplyT(func(v ResourceLfTagsTable) string { return v.DatabaseName }).(pulumi.StringOutput)
}

// Name of the table.
func (o ResourceLfTagsTableOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceLfTagsTable) *string { return v.Name }).(pulumi.StringPtrOutput)
}

// Whether to use a wildcard representing every table under a database. Defaults to `false`.
//
// The following arguments are optional:
func (o ResourceLfTagsTableOutput) Wildcard() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v ResourceLfTagsTable) *bool { return v.Wildcard }).(pulumi.BoolPtrOutput)
}

type ResourceLfTagsTablePtrOutput struct{ *pulumi.OutputState }

func (ResourceLfTagsTablePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceLfTagsTable)(nil)).Elem()
}

func (o ResourceLfTagsTablePtrOutput) ToResourceLfTagsTablePtrOutput() ResourceLfTagsTablePtrOutput {
	return o
}

func (o ResourceLfTagsTablePtrOutput) ToResourceLfTagsTablePtrOutputWithContext(ctx context.Context) ResourceLfTagsTablePtrOutput {
	return o
}

func (o ResourceLfTagsTablePtrOutput) Elem() ResourceLfTagsTableOutput {
	return o.ApplyT(func(v *ResourceLfTagsTable) ResourceLfTagsTable {
		if v != nil {
			return *v
		}
		var ret ResourceLfTagsTable
		return ret
	}).(ResourceLfTagsTableOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o ResourceLfTagsTablePtrOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceLfTagsTable) *string {
		if v == nil {
			return nil
		}
		return v.CatalogId
	}).(pulumi.StringPtrOutput)
}

// Name of the database for the table. Unique to a Data Catalog.
func (o ResourceLfTagsTablePtrOutput) DatabaseName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceLfTagsTable) *string {
		if v == nil {
			return nil
		}
		return &v.DatabaseName
	}).(pulumi.StringPtrOutput)
}

// Name of the table.
func (o ResourceLfTagsTablePtrOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceLfTagsTable) *string {
		if v == nil {
			return nil
		}
		return v.Name
	}).(pulumi.StringPtrOutput)
}

// Whether to use a wildcard representing every table under a database. Defaults to `false`.
//
// The following arguments are optional:
func (o ResourceLfTagsTablePtrOutput) Wildcard() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *ResourceLfTagsTable) *bool {
		if v == nil {
			return nil
		}
		return v.Wildcard
	}).(pulumi.BoolPtrOutput)
}

type ResourceLfTagsTableWithColumns struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId *string `pulumi:"catalogId"`
	// Set of column names for the table.
	ColumnNames []string `pulumi:"columnNames"`
	// Name of the database for the table with columns resource. Unique to the Data Catalog.
	DatabaseName string `pulumi:"databaseName"`
	// Set of column names for the table to exclude. If `excludedColumnNames` is included, `wildcard` must be set to `true` to avoid the provider reporting a difference.
	ExcludedColumnNames []string `pulumi:"excludedColumnNames"`
	// Name of the table resource.
	Name string `pulumi:"name"`
	// Whether to use a column wildcard. If `excludedColumnNames` is included, `wildcard` must be set to `true` to avoid the provider reporting a difference.
	//
	// The following arguments are optional:
	Wildcard *bool `pulumi:"wildcard"`
}

// ResourceLfTagsTableWithColumnsInput is an input type that accepts ResourceLfTagsTableWithColumnsArgs and ResourceLfTagsTableWithColumnsOutput values.
// You can construct a concrete instance of `ResourceLfTagsTableWithColumnsInput` via:
//
//	ResourceLfTagsTableWithColumnsArgs{...}
type ResourceLfTagsTableWithColumnsInput interface {
	pulumi.Input

	ToResourceLfTagsTableWithColumnsOutput() ResourceLfTagsTableWithColumnsOutput
	ToResourceLfTagsTableWithColumnsOutputWithContext(context.Context) ResourceLfTagsTableWithColumnsOutput
}

type ResourceLfTagsTableWithColumnsArgs struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId pulumi.StringPtrInput `pulumi:"catalogId"`
	// Set of column names for the table.
	ColumnNames pulumi.StringArrayInput `pulumi:"columnNames"`
	// Name of the database for the table with columns resource. Unique to the Data Catalog.
	DatabaseName pulumi.StringInput `pulumi:"databaseName"`
	// Set of column names for the table to exclude. If `excludedColumnNames` is included, `wildcard` must be set to `true` to avoid the provider reporting a difference.
	ExcludedColumnNames pulumi.StringArrayInput `pulumi:"excludedColumnNames"`
	// Name of the table resource.
	Name pulumi.StringInput `pulumi:"name"`
	// Whether to use a column wildcard. If `excludedColumnNames` is included, `wildcard` must be set to `true` to avoid the provider reporting a difference.
	//
	// The following arguments are optional:
	Wildcard pulumi.BoolPtrInput `pulumi:"wildcard"`
}

func (ResourceLfTagsTableWithColumnsArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceLfTagsTableWithColumns)(nil)).Elem()
}

func (i ResourceLfTagsTableWithColumnsArgs) ToResourceLfTagsTableWithColumnsOutput() ResourceLfTagsTableWithColumnsOutput {
	return i.ToResourceLfTagsTableWithColumnsOutputWithContext(context.Background())
}

func (i ResourceLfTagsTableWithColumnsArgs) ToResourceLfTagsTableWithColumnsOutputWithContext(ctx context.Context) ResourceLfTagsTableWithColumnsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagsTableWithColumnsOutput)
}

func (i ResourceLfTagsTableWithColumnsArgs) ToResourceLfTagsTableWithColumnsPtrOutput() ResourceLfTagsTableWithColumnsPtrOutput {
	return i.ToResourceLfTagsTableWithColumnsPtrOutputWithContext(context.Background())
}

func (i ResourceLfTagsTableWithColumnsArgs) ToResourceLfTagsTableWithColumnsPtrOutputWithContext(ctx context.Context) ResourceLfTagsTableWithColumnsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagsTableWithColumnsOutput).ToResourceLfTagsTableWithColumnsPtrOutputWithContext(ctx)
}

// ResourceLfTagsTableWithColumnsPtrInput is an input type that accepts ResourceLfTagsTableWithColumnsArgs, ResourceLfTagsTableWithColumnsPtr and ResourceLfTagsTableWithColumnsPtrOutput values.
// You can construct a concrete instance of `ResourceLfTagsTableWithColumnsPtrInput` via:
//
//	        ResourceLfTagsTableWithColumnsArgs{...}
//
//	or:
//
//	        nil
type ResourceLfTagsTableWithColumnsPtrInput interface {
	pulumi.Input

	ToResourceLfTagsTableWithColumnsPtrOutput() ResourceLfTagsTableWithColumnsPtrOutput
	ToResourceLfTagsTableWithColumnsPtrOutputWithContext(context.Context) ResourceLfTagsTableWithColumnsPtrOutput
}

type resourceLfTagsTableWithColumnsPtrType ResourceLfTagsTableWithColumnsArgs

func ResourceLfTagsTableWithColumnsPtr(v *ResourceLfTagsTableWithColumnsArgs) ResourceLfTagsTableWithColumnsPtrInput {
	return (*resourceLfTagsTableWithColumnsPtrType)(v)
}

func (*resourceLfTagsTableWithColumnsPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceLfTagsTableWithColumns)(nil)).Elem()
}

func (i *resourceLfTagsTableWithColumnsPtrType) ToResourceLfTagsTableWithColumnsPtrOutput() ResourceLfTagsTableWithColumnsPtrOutput {
	return i.ToResourceLfTagsTableWithColumnsPtrOutputWithContext(context.Background())
}

func (i *resourceLfTagsTableWithColumnsPtrType) ToResourceLfTagsTableWithColumnsPtrOutputWithContext(ctx context.Context) ResourceLfTagsTableWithColumnsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(ResourceLfTagsTableWithColumnsPtrOutput)
}

type ResourceLfTagsTableWithColumnsOutput struct{ *pulumi.OutputState }

func (ResourceLfTagsTableWithColumnsOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*ResourceLfTagsTableWithColumns)(nil)).Elem()
}

func (o ResourceLfTagsTableWithColumnsOutput) ToResourceLfTagsTableWithColumnsOutput() ResourceLfTagsTableWithColumnsOutput {
	return o
}

func (o ResourceLfTagsTableWithColumnsOutput) ToResourceLfTagsTableWithColumnsOutputWithContext(ctx context.Context) ResourceLfTagsTableWithColumnsOutput {
	return o
}

func (o ResourceLfTagsTableWithColumnsOutput) ToResourceLfTagsTableWithColumnsPtrOutput() ResourceLfTagsTableWithColumnsPtrOutput {
	return o.ToResourceLfTagsTableWithColumnsPtrOutputWithContext(context.Background())
}

func (o ResourceLfTagsTableWithColumnsOutput) ToResourceLfTagsTableWithColumnsPtrOutputWithContext(ctx context.Context) ResourceLfTagsTableWithColumnsPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v ResourceLfTagsTableWithColumns) *ResourceLfTagsTableWithColumns {
		return &v
	}).(ResourceLfTagsTableWithColumnsPtrOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o ResourceLfTagsTableWithColumnsOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v ResourceLfTagsTableWithColumns) *string { return v.CatalogId }).(pulumi.StringPtrOutput)
}

// Set of column names for the table.
func (o ResourceLfTagsTableWithColumnsOutput) ColumnNames() pulumi.StringArrayOutput {
	return o.ApplyT(func(v ResourceLfTagsTableWithColumns) []string { return v.ColumnNames }).(pulumi.StringArrayOutput)
}

// Name of the database for the table with columns resource. Unique to the Data Catalog.
func (o ResourceLfTagsTableWithColumnsOutput) DatabaseName() pulumi.StringOutput {
	return o.ApplyT(func(v ResourceLfTagsTableWithColumns) string { return v.DatabaseName }).(pulumi.StringOutput)
}

// Set of column names for the table to exclude. If `excludedColumnNames` is included, `wildcard` must be set to `true` to avoid the provider reporting a difference.
func (o ResourceLfTagsTableWithColumnsOutput) ExcludedColumnNames() pulumi.StringArrayOutput {
	return o.ApplyT(func(v ResourceLfTagsTableWithColumns) []string { return v.ExcludedColumnNames }).(pulumi.StringArrayOutput)
}

// Name of the table resource.
func (o ResourceLfTagsTableWithColumnsOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v ResourceLfTagsTableWithColumns) string { return v.Name }).(pulumi.StringOutput)
}

// Whether to use a column wildcard. If `excludedColumnNames` is included, `wildcard` must be set to `true` to avoid the provider reporting a difference.
//
// The following arguments are optional:
func (o ResourceLfTagsTableWithColumnsOutput) Wildcard() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v ResourceLfTagsTableWithColumns) *bool { return v.Wildcard }).(pulumi.BoolPtrOutput)
}

type ResourceLfTagsTableWithColumnsPtrOutput struct{ *pulumi.OutputState }

func (ResourceLfTagsTableWithColumnsPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**ResourceLfTagsTableWithColumns)(nil)).Elem()
}

func (o ResourceLfTagsTableWithColumnsPtrOutput) ToResourceLfTagsTableWithColumnsPtrOutput() ResourceLfTagsTableWithColumnsPtrOutput {
	return o
}

func (o ResourceLfTagsTableWithColumnsPtrOutput) ToResourceLfTagsTableWithColumnsPtrOutputWithContext(ctx context.Context) ResourceLfTagsTableWithColumnsPtrOutput {
	return o
}

func (o ResourceLfTagsTableWithColumnsPtrOutput) Elem() ResourceLfTagsTableWithColumnsOutput {
	return o.ApplyT(func(v *ResourceLfTagsTableWithColumns) ResourceLfTagsTableWithColumns {
		if v != nil {
			return *v
		}
		var ret ResourceLfTagsTableWithColumns
		return ret
	}).(ResourceLfTagsTableWithColumnsOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o ResourceLfTagsTableWithColumnsPtrOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceLfTagsTableWithColumns) *string {
		if v == nil {
			return nil
		}
		return v.CatalogId
	}).(pulumi.StringPtrOutput)
}

// Set of column names for the table.
func (o ResourceLfTagsTableWithColumnsPtrOutput) ColumnNames() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *ResourceLfTagsTableWithColumns) []string {
		if v == nil {
			return nil
		}
		return v.ColumnNames
	}).(pulumi.StringArrayOutput)
}

// Name of the database for the table with columns resource. Unique to the Data Catalog.
func (o ResourceLfTagsTableWithColumnsPtrOutput) DatabaseName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceLfTagsTableWithColumns) *string {
		if v == nil {
			return nil
		}
		return &v.DatabaseName
	}).(pulumi.StringPtrOutput)
}

// Set of column names for the table to exclude. If `excludedColumnNames` is included, `wildcard` must be set to `true` to avoid the provider reporting a difference.
func (o ResourceLfTagsTableWithColumnsPtrOutput) ExcludedColumnNames() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *ResourceLfTagsTableWithColumns) []string {
		if v == nil {
			return nil
		}
		return v.ExcludedColumnNames
	}).(pulumi.StringArrayOutput)
}

// Name of the table resource.
func (o ResourceLfTagsTableWithColumnsPtrOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *ResourceLfTagsTableWithColumns) *string {
		if v == nil {
			return nil
		}
		return &v.Name
	}).(pulumi.StringPtrOutput)
}

// Whether to use a column wildcard. If `excludedColumnNames` is included, `wildcard` must be set to `true` to avoid the provider reporting a difference.
//
// The following arguments are optional:
func (o ResourceLfTagsTableWithColumnsPtrOutput) Wildcard() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *ResourceLfTagsTableWithColumns) *bool {
		if v == nil {
			return nil
		}
		return v.Wildcard
	}).(pulumi.BoolPtrOutput)
}

type GetDataLakeSettingsCreateDatabaseDefaultPermission struct {
	// List of permissions granted to the principal.
	Permissions []string `pulumi:"permissions"`
	// Principal who is granted permissions.
	Principal string `pulumi:"principal"`
}

// GetDataLakeSettingsCreateDatabaseDefaultPermissionInput is an input type that accepts GetDataLakeSettingsCreateDatabaseDefaultPermissionArgs and GetDataLakeSettingsCreateDatabaseDefaultPermissionOutput values.
// You can construct a concrete instance of `GetDataLakeSettingsCreateDatabaseDefaultPermissionInput` via:
//
//	GetDataLakeSettingsCreateDatabaseDefaultPermissionArgs{...}
type GetDataLakeSettingsCreateDatabaseDefaultPermissionInput interface {
	pulumi.Input

	ToGetDataLakeSettingsCreateDatabaseDefaultPermissionOutput() GetDataLakeSettingsCreateDatabaseDefaultPermissionOutput
	ToGetDataLakeSettingsCreateDatabaseDefaultPermissionOutputWithContext(context.Context) GetDataLakeSettingsCreateDatabaseDefaultPermissionOutput
}

type GetDataLakeSettingsCreateDatabaseDefaultPermissionArgs struct {
	// List of permissions granted to the principal.
	Permissions pulumi.StringArrayInput `pulumi:"permissions"`
	// Principal who is granted permissions.
	Principal pulumi.StringInput `pulumi:"principal"`
}

func (GetDataLakeSettingsCreateDatabaseDefaultPermissionArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetDataLakeSettingsCreateDatabaseDefaultPermission)(nil)).Elem()
}

func (i GetDataLakeSettingsCreateDatabaseDefaultPermissionArgs) ToGetDataLakeSettingsCreateDatabaseDefaultPermissionOutput() GetDataLakeSettingsCreateDatabaseDefaultPermissionOutput {
	return i.ToGetDataLakeSettingsCreateDatabaseDefaultPermissionOutputWithContext(context.Background())
}

func (i GetDataLakeSettingsCreateDatabaseDefaultPermissionArgs) ToGetDataLakeSettingsCreateDatabaseDefaultPermissionOutputWithContext(ctx context.Context) GetDataLakeSettingsCreateDatabaseDefaultPermissionOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetDataLakeSettingsCreateDatabaseDefaultPermissionOutput)
}

// GetDataLakeSettingsCreateDatabaseDefaultPermissionArrayInput is an input type that accepts GetDataLakeSettingsCreateDatabaseDefaultPermissionArray and GetDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput values.
// You can construct a concrete instance of `GetDataLakeSettingsCreateDatabaseDefaultPermissionArrayInput` via:
//
//	GetDataLakeSettingsCreateDatabaseDefaultPermissionArray{ GetDataLakeSettingsCreateDatabaseDefaultPermissionArgs{...} }
type GetDataLakeSettingsCreateDatabaseDefaultPermissionArrayInput interface {
	pulumi.Input

	ToGetDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput() GetDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput
	ToGetDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutputWithContext(context.Context) GetDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput
}

type GetDataLakeSettingsCreateDatabaseDefaultPermissionArray []GetDataLakeSettingsCreateDatabaseDefaultPermissionInput

func (GetDataLakeSettingsCreateDatabaseDefaultPermissionArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]GetDataLakeSettingsCreateDatabaseDefaultPermission)(nil)).Elem()
}

func (i GetDataLakeSettingsCreateDatabaseDefaultPermissionArray) ToGetDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput() GetDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput {
	return i.ToGetDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutputWithContext(context.Background())
}

func (i GetDataLakeSettingsCreateDatabaseDefaultPermissionArray) ToGetDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutputWithContext(ctx context.Context) GetDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput)
}

type GetDataLakeSettingsCreateDatabaseDefaultPermissionOutput struct{ *pulumi.OutputState }

func (GetDataLakeSettingsCreateDatabaseDefaultPermissionOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetDataLakeSettingsCreateDatabaseDefaultPermission)(nil)).Elem()
}

func (o GetDataLakeSettingsCreateDatabaseDefaultPermissionOutput) ToGetDataLakeSettingsCreateDatabaseDefaultPermissionOutput() GetDataLakeSettingsCreateDatabaseDefaultPermissionOutput {
	return o
}

func (o GetDataLakeSettingsCreateDatabaseDefaultPermissionOutput) ToGetDataLakeSettingsCreateDatabaseDefaultPermissionOutputWithContext(ctx context.Context) GetDataLakeSettingsCreateDatabaseDefaultPermissionOutput {
	return o
}

// List of permissions granted to the principal.
func (o GetDataLakeSettingsCreateDatabaseDefaultPermissionOutput) Permissions() pulumi.StringArrayOutput {
	return o.ApplyT(func(v GetDataLakeSettingsCreateDatabaseDefaultPermission) []string { return v.Permissions }).(pulumi.StringArrayOutput)
}

// Principal who is granted permissions.
func (o GetDataLakeSettingsCreateDatabaseDefaultPermissionOutput) Principal() pulumi.StringOutput {
	return o.ApplyT(func(v GetDataLakeSettingsCreateDatabaseDefaultPermission) string { return v.Principal }).(pulumi.StringOutput)
}

type GetDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput struct{ *pulumi.OutputState }

func (GetDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]GetDataLakeSettingsCreateDatabaseDefaultPermission)(nil)).Elem()
}

func (o GetDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput) ToGetDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput() GetDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput {
	return o
}

func (o GetDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput) ToGetDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutputWithContext(ctx context.Context) GetDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput {
	return o
}

func (o GetDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput) Index(i pulumi.IntInput) GetDataLakeSettingsCreateDatabaseDefaultPermissionOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetDataLakeSettingsCreateDatabaseDefaultPermission {
		return vs[0].([]GetDataLakeSettingsCreateDatabaseDefaultPermission)[vs[1].(int)]
	}).(GetDataLakeSettingsCreateDatabaseDefaultPermissionOutput)
}

type GetDataLakeSettingsCreateTableDefaultPermission struct {
	// List of permissions granted to the principal.
	Permissions []string `pulumi:"permissions"`
	// Principal who is granted permissions.
	Principal string `pulumi:"principal"`
}

// GetDataLakeSettingsCreateTableDefaultPermissionInput is an input type that accepts GetDataLakeSettingsCreateTableDefaultPermissionArgs and GetDataLakeSettingsCreateTableDefaultPermissionOutput values.
// You can construct a concrete instance of `GetDataLakeSettingsCreateTableDefaultPermissionInput` via:
//
//	GetDataLakeSettingsCreateTableDefaultPermissionArgs{...}
type GetDataLakeSettingsCreateTableDefaultPermissionInput interface {
	pulumi.Input

	ToGetDataLakeSettingsCreateTableDefaultPermissionOutput() GetDataLakeSettingsCreateTableDefaultPermissionOutput
	ToGetDataLakeSettingsCreateTableDefaultPermissionOutputWithContext(context.Context) GetDataLakeSettingsCreateTableDefaultPermissionOutput
}

type GetDataLakeSettingsCreateTableDefaultPermissionArgs struct {
	// List of permissions granted to the principal.
	Permissions pulumi.StringArrayInput `pulumi:"permissions"`
	// Principal who is granted permissions.
	Principal pulumi.StringInput `pulumi:"principal"`
}

func (GetDataLakeSettingsCreateTableDefaultPermissionArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetDataLakeSettingsCreateTableDefaultPermission)(nil)).Elem()
}

func (i GetDataLakeSettingsCreateTableDefaultPermissionArgs) ToGetDataLakeSettingsCreateTableDefaultPermissionOutput() GetDataLakeSettingsCreateTableDefaultPermissionOutput {
	return i.ToGetDataLakeSettingsCreateTableDefaultPermissionOutputWithContext(context.Background())
}

func (i GetDataLakeSettingsCreateTableDefaultPermissionArgs) ToGetDataLakeSettingsCreateTableDefaultPermissionOutputWithContext(ctx context.Context) GetDataLakeSettingsCreateTableDefaultPermissionOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetDataLakeSettingsCreateTableDefaultPermissionOutput)
}

// GetDataLakeSettingsCreateTableDefaultPermissionArrayInput is an input type that accepts GetDataLakeSettingsCreateTableDefaultPermissionArray and GetDataLakeSettingsCreateTableDefaultPermissionArrayOutput values.
// You can construct a concrete instance of `GetDataLakeSettingsCreateTableDefaultPermissionArrayInput` via:
//
//	GetDataLakeSettingsCreateTableDefaultPermissionArray{ GetDataLakeSettingsCreateTableDefaultPermissionArgs{...} }
type GetDataLakeSettingsCreateTableDefaultPermissionArrayInput interface {
	pulumi.Input

	ToGetDataLakeSettingsCreateTableDefaultPermissionArrayOutput() GetDataLakeSettingsCreateTableDefaultPermissionArrayOutput
	ToGetDataLakeSettingsCreateTableDefaultPermissionArrayOutputWithContext(context.Context) GetDataLakeSettingsCreateTableDefaultPermissionArrayOutput
}

type GetDataLakeSettingsCreateTableDefaultPermissionArray []GetDataLakeSettingsCreateTableDefaultPermissionInput

func (GetDataLakeSettingsCreateTableDefaultPermissionArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]GetDataLakeSettingsCreateTableDefaultPermission)(nil)).Elem()
}

func (i GetDataLakeSettingsCreateTableDefaultPermissionArray) ToGetDataLakeSettingsCreateTableDefaultPermissionArrayOutput() GetDataLakeSettingsCreateTableDefaultPermissionArrayOutput {
	return i.ToGetDataLakeSettingsCreateTableDefaultPermissionArrayOutputWithContext(context.Background())
}

func (i GetDataLakeSettingsCreateTableDefaultPermissionArray) ToGetDataLakeSettingsCreateTableDefaultPermissionArrayOutputWithContext(ctx context.Context) GetDataLakeSettingsCreateTableDefaultPermissionArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetDataLakeSettingsCreateTableDefaultPermissionArrayOutput)
}

type GetDataLakeSettingsCreateTableDefaultPermissionOutput struct{ *pulumi.OutputState }

func (GetDataLakeSettingsCreateTableDefaultPermissionOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetDataLakeSettingsCreateTableDefaultPermission)(nil)).Elem()
}

func (o GetDataLakeSettingsCreateTableDefaultPermissionOutput) ToGetDataLakeSettingsCreateTableDefaultPermissionOutput() GetDataLakeSettingsCreateTableDefaultPermissionOutput {
	return o
}

func (o GetDataLakeSettingsCreateTableDefaultPermissionOutput) ToGetDataLakeSettingsCreateTableDefaultPermissionOutputWithContext(ctx context.Context) GetDataLakeSettingsCreateTableDefaultPermissionOutput {
	return o
}

// List of permissions granted to the principal.
func (o GetDataLakeSettingsCreateTableDefaultPermissionOutput) Permissions() pulumi.StringArrayOutput {
	return o.ApplyT(func(v GetDataLakeSettingsCreateTableDefaultPermission) []string { return v.Permissions }).(pulumi.StringArrayOutput)
}

// Principal who is granted permissions.
func (o GetDataLakeSettingsCreateTableDefaultPermissionOutput) Principal() pulumi.StringOutput {
	return o.ApplyT(func(v GetDataLakeSettingsCreateTableDefaultPermission) string { return v.Principal }).(pulumi.StringOutput)
}

type GetDataLakeSettingsCreateTableDefaultPermissionArrayOutput struct{ *pulumi.OutputState }

func (GetDataLakeSettingsCreateTableDefaultPermissionArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]GetDataLakeSettingsCreateTableDefaultPermission)(nil)).Elem()
}

func (o GetDataLakeSettingsCreateTableDefaultPermissionArrayOutput) ToGetDataLakeSettingsCreateTableDefaultPermissionArrayOutput() GetDataLakeSettingsCreateTableDefaultPermissionArrayOutput {
	return o
}

func (o GetDataLakeSettingsCreateTableDefaultPermissionArrayOutput) ToGetDataLakeSettingsCreateTableDefaultPermissionArrayOutputWithContext(ctx context.Context) GetDataLakeSettingsCreateTableDefaultPermissionArrayOutput {
	return o
}

func (o GetDataLakeSettingsCreateTableDefaultPermissionArrayOutput) Index(i pulumi.IntInput) GetDataLakeSettingsCreateTableDefaultPermissionOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetDataLakeSettingsCreateTableDefaultPermission {
		return vs[0].([]GetDataLakeSettingsCreateTableDefaultPermission)[vs[1].(int)]
	}).(GetDataLakeSettingsCreateTableDefaultPermissionOutput)
}

type GetPermissionsDataCellsFilter struct {
	// The name of the database.
	DatabaseName string `pulumi:"databaseName"`
	// The name of the data cells filter.
	Name string `pulumi:"name"`
	// The ID of the Data Catalog.
	TableCatalogId string `pulumi:"tableCatalogId"`
	// The name of the table.
	TableName string `pulumi:"tableName"`
}

// GetPermissionsDataCellsFilterInput is an input type that accepts GetPermissionsDataCellsFilterArgs and GetPermissionsDataCellsFilterOutput values.
// You can construct a concrete instance of `GetPermissionsDataCellsFilterInput` via:
//
//	GetPermissionsDataCellsFilterArgs{...}
type GetPermissionsDataCellsFilterInput interface {
	pulumi.Input

	ToGetPermissionsDataCellsFilterOutput() GetPermissionsDataCellsFilterOutput
	ToGetPermissionsDataCellsFilterOutputWithContext(context.Context) GetPermissionsDataCellsFilterOutput
}

type GetPermissionsDataCellsFilterArgs struct {
	// The name of the database.
	DatabaseName pulumi.StringInput `pulumi:"databaseName"`
	// The name of the data cells filter.
	Name pulumi.StringInput `pulumi:"name"`
	// The ID of the Data Catalog.
	TableCatalogId pulumi.StringInput `pulumi:"tableCatalogId"`
	// The name of the table.
	TableName pulumi.StringInput `pulumi:"tableName"`
}

func (GetPermissionsDataCellsFilterArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPermissionsDataCellsFilter)(nil)).Elem()
}

func (i GetPermissionsDataCellsFilterArgs) ToGetPermissionsDataCellsFilterOutput() GetPermissionsDataCellsFilterOutput {
	return i.ToGetPermissionsDataCellsFilterOutputWithContext(context.Background())
}

func (i GetPermissionsDataCellsFilterArgs) ToGetPermissionsDataCellsFilterOutputWithContext(ctx context.Context) GetPermissionsDataCellsFilterOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPermissionsDataCellsFilterOutput)
}

func (i GetPermissionsDataCellsFilterArgs) ToGetPermissionsDataCellsFilterPtrOutput() GetPermissionsDataCellsFilterPtrOutput {
	return i.ToGetPermissionsDataCellsFilterPtrOutputWithContext(context.Background())
}

func (i GetPermissionsDataCellsFilterArgs) ToGetPermissionsDataCellsFilterPtrOutputWithContext(ctx context.Context) GetPermissionsDataCellsFilterPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPermissionsDataCellsFilterOutput).ToGetPermissionsDataCellsFilterPtrOutputWithContext(ctx)
}

// GetPermissionsDataCellsFilterPtrInput is an input type that accepts GetPermissionsDataCellsFilterArgs, GetPermissionsDataCellsFilterPtr and GetPermissionsDataCellsFilterPtrOutput values.
// You can construct a concrete instance of `GetPermissionsDataCellsFilterPtrInput` via:
//
//	        GetPermissionsDataCellsFilterArgs{...}
//
//	or:
//
//	        nil
type GetPermissionsDataCellsFilterPtrInput interface {
	pulumi.Input

	ToGetPermissionsDataCellsFilterPtrOutput() GetPermissionsDataCellsFilterPtrOutput
	ToGetPermissionsDataCellsFilterPtrOutputWithContext(context.Context) GetPermissionsDataCellsFilterPtrOutput
}

type getPermissionsDataCellsFilterPtrType GetPermissionsDataCellsFilterArgs

func GetPermissionsDataCellsFilterPtr(v *GetPermissionsDataCellsFilterArgs) GetPermissionsDataCellsFilterPtrInput {
	return (*getPermissionsDataCellsFilterPtrType)(v)
}

func (*getPermissionsDataCellsFilterPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**GetPermissionsDataCellsFilter)(nil)).Elem()
}

func (i *getPermissionsDataCellsFilterPtrType) ToGetPermissionsDataCellsFilterPtrOutput() GetPermissionsDataCellsFilterPtrOutput {
	return i.ToGetPermissionsDataCellsFilterPtrOutputWithContext(context.Background())
}

func (i *getPermissionsDataCellsFilterPtrType) ToGetPermissionsDataCellsFilterPtrOutputWithContext(ctx context.Context) GetPermissionsDataCellsFilterPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPermissionsDataCellsFilterPtrOutput)
}

type GetPermissionsDataCellsFilterOutput struct{ *pulumi.OutputState }

func (GetPermissionsDataCellsFilterOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPermissionsDataCellsFilter)(nil)).Elem()
}

func (o GetPermissionsDataCellsFilterOutput) ToGetPermissionsDataCellsFilterOutput() GetPermissionsDataCellsFilterOutput {
	return o
}

func (o GetPermissionsDataCellsFilterOutput) ToGetPermissionsDataCellsFilterOutputWithContext(ctx context.Context) GetPermissionsDataCellsFilterOutput {
	return o
}

func (o GetPermissionsDataCellsFilterOutput) ToGetPermissionsDataCellsFilterPtrOutput() GetPermissionsDataCellsFilterPtrOutput {
	return o.ToGetPermissionsDataCellsFilterPtrOutputWithContext(context.Background())
}

func (o GetPermissionsDataCellsFilterOutput) ToGetPermissionsDataCellsFilterPtrOutputWithContext(ctx context.Context) GetPermissionsDataCellsFilterPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v GetPermissionsDataCellsFilter) *GetPermissionsDataCellsFilter {
		return &v
	}).(GetPermissionsDataCellsFilterPtrOutput)
}

// The name of the database.
func (o GetPermissionsDataCellsFilterOutput) DatabaseName() pulumi.StringOutput {
	return o.ApplyT(func(v GetPermissionsDataCellsFilter) string { return v.DatabaseName }).(pulumi.StringOutput)
}

// The name of the data cells filter.
func (o GetPermissionsDataCellsFilterOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v GetPermissionsDataCellsFilter) string { return v.Name }).(pulumi.StringOutput)
}

// The ID of the Data Catalog.
func (o GetPermissionsDataCellsFilterOutput) TableCatalogId() pulumi.StringOutput {
	return o.ApplyT(func(v GetPermissionsDataCellsFilter) string { return v.TableCatalogId }).(pulumi.StringOutput)
}

// The name of the table.
func (o GetPermissionsDataCellsFilterOutput) TableName() pulumi.StringOutput {
	return o.ApplyT(func(v GetPermissionsDataCellsFilter) string { return v.TableName }).(pulumi.StringOutput)
}

type GetPermissionsDataCellsFilterPtrOutput struct{ *pulumi.OutputState }

func (GetPermissionsDataCellsFilterPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**GetPermissionsDataCellsFilter)(nil)).Elem()
}

func (o GetPermissionsDataCellsFilterPtrOutput) ToGetPermissionsDataCellsFilterPtrOutput() GetPermissionsDataCellsFilterPtrOutput {
	return o
}

func (o GetPermissionsDataCellsFilterPtrOutput) ToGetPermissionsDataCellsFilterPtrOutputWithContext(ctx context.Context) GetPermissionsDataCellsFilterPtrOutput {
	return o
}

func (o GetPermissionsDataCellsFilterPtrOutput) Elem() GetPermissionsDataCellsFilterOutput {
	return o.ApplyT(func(v *GetPermissionsDataCellsFilter) GetPermissionsDataCellsFilter {
		if v != nil {
			return *v
		}
		var ret GetPermissionsDataCellsFilter
		return ret
	}).(GetPermissionsDataCellsFilterOutput)
}

// The name of the database.
func (o GetPermissionsDataCellsFilterPtrOutput) DatabaseName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *GetPermissionsDataCellsFilter) *string {
		if v == nil {
			return nil
		}
		return &v.DatabaseName
	}).(pulumi.StringPtrOutput)
}

// The name of the data cells filter.
func (o GetPermissionsDataCellsFilterPtrOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *GetPermissionsDataCellsFilter) *string {
		if v == nil {
			return nil
		}
		return &v.Name
	}).(pulumi.StringPtrOutput)
}

// The ID of the Data Catalog.
func (o GetPermissionsDataCellsFilterPtrOutput) TableCatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *GetPermissionsDataCellsFilter) *string {
		if v == nil {
			return nil
		}
		return &v.TableCatalogId
	}).(pulumi.StringPtrOutput)
}

// The name of the table.
func (o GetPermissionsDataCellsFilterPtrOutput) TableName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *GetPermissionsDataCellsFilter) *string {
		if v == nil {
			return nil
		}
		return &v.TableName
	}).(pulumi.StringPtrOutput)
}

type GetPermissionsDataLocation struct {
	// ARN that uniquely identifies the data location resource.
	//
	// The following argument is optional:
	Arn string `pulumi:"arn"`
	// Identifier for the Data Catalog where the location is registered with Lake Formation. By default, it is the account ID of the caller.
	CatalogId string `pulumi:"catalogId"`
}

// GetPermissionsDataLocationInput is an input type that accepts GetPermissionsDataLocationArgs and GetPermissionsDataLocationOutput values.
// You can construct a concrete instance of `GetPermissionsDataLocationInput` via:
//
//	GetPermissionsDataLocationArgs{...}
type GetPermissionsDataLocationInput interface {
	pulumi.Input

	ToGetPermissionsDataLocationOutput() GetPermissionsDataLocationOutput
	ToGetPermissionsDataLocationOutputWithContext(context.Context) GetPermissionsDataLocationOutput
}

type GetPermissionsDataLocationArgs struct {
	// ARN that uniquely identifies the data location resource.
	//
	// The following argument is optional:
	Arn pulumi.StringInput `pulumi:"arn"`
	// Identifier for the Data Catalog where the location is registered with Lake Formation. By default, it is the account ID of the caller.
	CatalogId pulumi.StringInput `pulumi:"catalogId"`
}

func (GetPermissionsDataLocationArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPermissionsDataLocation)(nil)).Elem()
}

func (i GetPermissionsDataLocationArgs) ToGetPermissionsDataLocationOutput() GetPermissionsDataLocationOutput {
	return i.ToGetPermissionsDataLocationOutputWithContext(context.Background())
}

func (i GetPermissionsDataLocationArgs) ToGetPermissionsDataLocationOutputWithContext(ctx context.Context) GetPermissionsDataLocationOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPermissionsDataLocationOutput)
}

func (i GetPermissionsDataLocationArgs) ToGetPermissionsDataLocationPtrOutput() GetPermissionsDataLocationPtrOutput {
	return i.ToGetPermissionsDataLocationPtrOutputWithContext(context.Background())
}

func (i GetPermissionsDataLocationArgs) ToGetPermissionsDataLocationPtrOutputWithContext(ctx context.Context) GetPermissionsDataLocationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPermissionsDataLocationOutput).ToGetPermissionsDataLocationPtrOutputWithContext(ctx)
}

// GetPermissionsDataLocationPtrInput is an input type that accepts GetPermissionsDataLocationArgs, GetPermissionsDataLocationPtr and GetPermissionsDataLocationPtrOutput values.
// You can construct a concrete instance of `GetPermissionsDataLocationPtrInput` via:
//
//	        GetPermissionsDataLocationArgs{...}
//
//	or:
//
//	        nil
type GetPermissionsDataLocationPtrInput interface {
	pulumi.Input

	ToGetPermissionsDataLocationPtrOutput() GetPermissionsDataLocationPtrOutput
	ToGetPermissionsDataLocationPtrOutputWithContext(context.Context) GetPermissionsDataLocationPtrOutput
}

type getPermissionsDataLocationPtrType GetPermissionsDataLocationArgs

func GetPermissionsDataLocationPtr(v *GetPermissionsDataLocationArgs) GetPermissionsDataLocationPtrInput {
	return (*getPermissionsDataLocationPtrType)(v)
}

func (*getPermissionsDataLocationPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**GetPermissionsDataLocation)(nil)).Elem()
}

func (i *getPermissionsDataLocationPtrType) ToGetPermissionsDataLocationPtrOutput() GetPermissionsDataLocationPtrOutput {
	return i.ToGetPermissionsDataLocationPtrOutputWithContext(context.Background())
}

func (i *getPermissionsDataLocationPtrType) ToGetPermissionsDataLocationPtrOutputWithContext(ctx context.Context) GetPermissionsDataLocationPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPermissionsDataLocationPtrOutput)
}

type GetPermissionsDataLocationOutput struct{ *pulumi.OutputState }

func (GetPermissionsDataLocationOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPermissionsDataLocation)(nil)).Elem()
}

func (o GetPermissionsDataLocationOutput) ToGetPermissionsDataLocationOutput() GetPermissionsDataLocationOutput {
	return o
}

func (o GetPermissionsDataLocationOutput) ToGetPermissionsDataLocationOutputWithContext(ctx context.Context) GetPermissionsDataLocationOutput {
	return o
}

func (o GetPermissionsDataLocationOutput) ToGetPermissionsDataLocationPtrOutput() GetPermissionsDataLocationPtrOutput {
	return o.ToGetPermissionsDataLocationPtrOutputWithContext(context.Background())
}

func (o GetPermissionsDataLocationOutput) ToGetPermissionsDataLocationPtrOutputWithContext(ctx context.Context) GetPermissionsDataLocationPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v GetPermissionsDataLocation) *GetPermissionsDataLocation {
		return &v
	}).(GetPermissionsDataLocationPtrOutput)
}

// ARN that uniquely identifies the data location resource.
//
// The following argument is optional:
func (o GetPermissionsDataLocationOutput) Arn() pulumi.StringOutput {
	return o.ApplyT(func(v GetPermissionsDataLocation) string { return v.Arn }).(pulumi.StringOutput)
}

// Identifier for the Data Catalog where the location is registered with Lake Formation. By default, it is the account ID of the caller.
func (o GetPermissionsDataLocationOutput) CatalogId() pulumi.StringOutput {
	return o.ApplyT(func(v GetPermissionsDataLocation) string { return v.CatalogId }).(pulumi.StringOutput)
}

type GetPermissionsDataLocationPtrOutput struct{ *pulumi.OutputState }

func (GetPermissionsDataLocationPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**GetPermissionsDataLocation)(nil)).Elem()
}

func (o GetPermissionsDataLocationPtrOutput) ToGetPermissionsDataLocationPtrOutput() GetPermissionsDataLocationPtrOutput {
	return o
}

func (o GetPermissionsDataLocationPtrOutput) ToGetPermissionsDataLocationPtrOutputWithContext(ctx context.Context) GetPermissionsDataLocationPtrOutput {
	return o
}

func (o GetPermissionsDataLocationPtrOutput) Elem() GetPermissionsDataLocationOutput {
	return o.ApplyT(func(v *GetPermissionsDataLocation) GetPermissionsDataLocation {
		if v != nil {
			return *v
		}
		var ret GetPermissionsDataLocation
		return ret
	}).(GetPermissionsDataLocationOutput)
}

// ARN that uniquely identifies the data location resource.
//
// The following argument is optional:
func (o GetPermissionsDataLocationPtrOutput) Arn() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *GetPermissionsDataLocation) *string {
		if v == nil {
			return nil
		}
		return &v.Arn
	}).(pulumi.StringPtrOutput)
}

// Identifier for the Data Catalog where the location is registered with Lake Formation. By default, it is the account ID of the caller.
func (o GetPermissionsDataLocationPtrOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *GetPermissionsDataLocation) *string {
		if v == nil {
			return nil
		}
		return &v.CatalogId
	}).(pulumi.StringPtrOutput)
}

type GetPermissionsDatabase struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId string `pulumi:"catalogId"`
	// Name of the database resource. Unique to the Data Catalog.
	//
	// The following argument is optional:
	Name string `pulumi:"name"`
}

// GetPermissionsDatabaseInput is an input type that accepts GetPermissionsDatabaseArgs and GetPermissionsDatabaseOutput values.
// You can construct a concrete instance of `GetPermissionsDatabaseInput` via:
//
//	GetPermissionsDatabaseArgs{...}
type GetPermissionsDatabaseInput interface {
	pulumi.Input

	ToGetPermissionsDatabaseOutput() GetPermissionsDatabaseOutput
	ToGetPermissionsDatabaseOutputWithContext(context.Context) GetPermissionsDatabaseOutput
}

type GetPermissionsDatabaseArgs struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId pulumi.StringInput `pulumi:"catalogId"`
	// Name of the database resource. Unique to the Data Catalog.
	//
	// The following argument is optional:
	Name pulumi.StringInput `pulumi:"name"`
}

func (GetPermissionsDatabaseArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPermissionsDatabase)(nil)).Elem()
}

func (i GetPermissionsDatabaseArgs) ToGetPermissionsDatabaseOutput() GetPermissionsDatabaseOutput {
	return i.ToGetPermissionsDatabaseOutputWithContext(context.Background())
}

func (i GetPermissionsDatabaseArgs) ToGetPermissionsDatabaseOutputWithContext(ctx context.Context) GetPermissionsDatabaseOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPermissionsDatabaseOutput)
}

func (i GetPermissionsDatabaseArgs) ToGetPermissionsDatabasePtrOutput() GetPermissionsDatabasePtrOutput {
	return i.ToGetPermissionsDatabasePtrOutputWithContext(context.Background())
}

func (i GetPermissionsDatabaseArgs) ToGetPermissionsDatabasePtrOutputWithContext(ctx context.Context) GetPermissionsDatabasePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPermissionsDatabaseOutput).ToGetPermissionsDatabasePtrOutputWithContext(ctx)
}

// GetPermissionsDatabasePtrInput is an input type that accepts GetPermissionsDatabaseArgs, GetPermissionsDatabasePtr and GetPermissionsDatabasePtrOutput values.
// You can construct a concrete instance of `GetPermissionsDatabasePtrInput` via:
//
//	        GetPermissionsDatabaseArgs{...}
//
//	or:
//
//	        nil
type GetPermissionsDatabasePtrInput interface {
	pulumi.Input

	ToGetPermissionsDatabasePtrOutput() GetPermissionsDatabasePtrOutput
	ToGetPermissionsDatabasePtrOutputWithContext(context.Context) GetPermissionsDatabasePtrOutput
}

type getPermissionsDatabasePtrType GetPermissionsDatabaseArgs

func GetPermissionsDatabasePtr(v *GetPermissionsDatabaseArgs) GetPermissionsDatabasePtrInput {
	return (*getPermissionsDatabasePtrType)(v)
}

func (*getPermissionsDatabasePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**GetPermissionsDatabase)(nil)).Elem()
}

func (i *getPermissionsDatabasePtrType) ToGetPermissionsDatabasePtrOutput() GetPermissionsDatabasePtrOutput {
	return i.ToGetPermissionsDatabasePtrOutputWithContext(context.Background())
}

func (i *getPermissionsDatabasePtrType) ToGetPermissionsDatabasePtrOutputWithContext(ctx context.Context) GetPermissionsDatabasePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPermissionsDatabasePtrOutput)
}

type GetPermissionsDatabaseOutput struct{ *pulumi.OutputState }

func (GetPermissionsDatabaseOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPermissionsDatabase)(nil)).Elem()
}

func (o GetPermissionsDatabaseOutput) ToGetPermissionsDatabaseOutput() GetPermissionsDatabaseOutput {
	return o
}

func (o GetPermissionsDatabaseOutput) ToGetPermissionsDatabaseOutputWithContext(ctx context.Context) GetPermissionsDatabaseOutput {
	return o
}

func (o GetPermissionsDatabaseOutput) ToGetPermissionsDatabasePtrOutput() GetPermissionsDatabasePtrOutput {
	return o.ToGetPermissionsDatabasePtrOutputWithContext(context.Background())
}

func (o GetPermissionsDatabaseOutput) ToGetPermissionsDatabasePtrOutputWithContext(ctx context.Context) GetPermissionsDatabasePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v GetPermissionsDatabase) *GetPermissionsDatabase {
		return &v
	}).(GetPermissionsDatabasePtrOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o GetPermissionsDatabaseOutput) CatalogId() pulumi.StringOutput {
	return o.ApplyT(func(v GetPermissionsDatabase) string { return v.CatalogId }).(pulumi.StringOutput)
}

// Name of the database resource. Unique to the Data Catalog.
//
// The following argument is optional:
func (o GetPermissionsDatabaseOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v GetPermissionsDatabase) string { return v.Name }).(pulumi.StringOutput)
}

type GetPermissionsDatabasePtrOutput struct{ *pulumi.OutputState }

func (GetPermissionsDatabasePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**GetPermissionsDatabase)(nil)).Elem()
}

func (o GetPermissionsDatabasePtrOutput) ToGetPermissionsDatabasePtrOutput() GetPermissionsDatabasePtrOutput {
	return o
}

func (o GetPermissionsDatabasePtrOutput) ToGetPermissionsDatabasePtrOutputWithContext(ctx context.Context) GetPermissionsDatabasePtrOutput {
	return o
}

func (o GetPermissionsDatabasePtrOutput) Elem() GetPermissionsDatabaseOutput {
	return o.ApplyT(func(v *GetPermissionsDatabase) GetPermissionsDatabase {
		if v != nil {
			return *v
		}
		var ret GetPermissionsDatabase
		return ret
	}).(GetPermissionsDatabaseOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o GetPermissionsDatabasePtrOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *GetPermissionsDatabase) *string {
		if v == nil {
			return nil
		}
		return &v.CatalogId
	}).(pulumi.StringPtrOutput)
}

// Name of the database resource. Unique to the Data Catalog.
//
// The following argument is optional:
func (o GetPermissionsDatabasePtrOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *GetPermissionsDatabase) *string {
		if v == nil {
			return nil
		}
		return &v.Name
	}).(pulumi.StringPtrOutput)
}

type GetPermissionsLfTag struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId string `pulumi:"catalogId"`
	// Key-name for the tag.
	Key string `pulumi:"key"`
	// List of possible values an attribute can take.
	//
	// The following argument is optional:
	Values []string `pulumi:"values"`
}

// GetPermissionsLfTagInput is an input type that accepts GetPermissionsLfTagArgs and GetPermissionsLfTagOutput values.
// You can construct a concrete instance of `GetPermissionsLfTagInput` via:
//
//	GetPermissionsLfTagArgs{...}
type GetPermissionsLfTagInput interface {
	pulumi.Input

	ToGetPermissionsLfTagOutput() GetPermissionsLfTagOutput
	ToGetPermissionsLfTagOutputWithContext(context.Context) GetPermissionsLfTagOutput
}

type GetPermissionsLfTagArgs struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId pulumi.StringInput `pulumi:"catalogId"`
	// Key-name for the tag.
	Key pulumi.StringInput `pulumi:"key"`
	// List of possible values an attribute can take.
	//
	// The following argument is optional:
	Values pulumi.StringArrayInput `pulumi:"values"`
}

func (GetPermissionsLfTagArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPermissionsLfTag)(nil)).Elem()
}

func (i GetPermissionsLfTagArgs) ToGetPermissionsLfTagOutput() GetPermissionsLfTagOutput {
	return i.ToGetPermissionsLfTagOutputWithContext(context.Background())
}

func (i GetPermissionsLfTagArgs) ToGetPermissionsLfTagOutputWithContext(ctx context.Context) GetPermissionsLfTagOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPermissionsLfTagOutput)
}

func (i GetPermissionsLfTagArgs) ToGetPermissionsLfTagPtrOutput() GetPermissionsLfTagPtrOutput {
	return i.ToGetPermissionsLfTagPtrOutputWithContext(context.Background())
}

func (i GetPermissionsLfTagArgs) ToGetPermissionsLfTagPtrOutputWithContext(ctx context.Context) GetPermissionsLfTagPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPermissionsLfTagOutput).ToGetPermissionsLfTagPtrOutputWithContext(ctx)
}

// GetPermissionsLfTagPtrInput is an input type that accepts GetPermissionsLfTagArgs, GetPermissionsLfTagPtr and GetPermissionsLfTagPtrOutput values.
// You can construct a concrete instance of `GetPermissionsLfTagPtrInput` via:
//
//	        GetPermissionsLfTagArgs{...}
//
//	or:
//
//	        nil
type GetPermissionsLfTagPtrInput interface {
	pulumi.Input

	ToGetPermissionsLfTagPtrOutput() GetPermissionsLfTagPtrOutput
	ToGetPermissionsLfTagPtrOutputWithContext(context.Context) GetPermissionsLfTagPtrOutput
}

type getPermissionsLfTagPtrType GetPermissionsLfTagArgs

func GetPermissionsLfTagPtr(v *GetPermissionsLfTagArgs) GetPermissionsLfTagPtrInput {
	return (*getPermissionsLfTagPtrType)(v)
}

func (*getPermissionsLfTagPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**GetPermissionsLfTag)(nil)).Elem()
}

func (i *getPermissionsLfTagPtrType) ToGetPermissionsLfTagPtrOutput() GetPermissionsLfTagPtrOutput {
	return i.ToGetPermissionsLfTagPtrOutputWithContext(context.Background())
}

func (i *getPermissionsLfTagPtrType) ToGetPermissionsLfTagPtrOutputWithContext(ctx context.Context) GetPermissionsLfTagPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPermissionsLfTagPtrOutput)
}

type GetPermissionsLfTagOutput struct{ *pulumi.OutputState }

func (GetPermissionsLfTagOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPermissionsLfTag)(nil)).Elem()
}

func (o GetPermissionsLfTagOutput) ToGetPermissionsLfTagOutput() GetPermissionsLfTagOutput {
	return o
}

func (o GetPermissionsLfTagOutput) ToGetPermissionsLfTagOutputWithContext(ctx context.Context) GetPermissionsLfTagOutput {
	return o
}

func (o GetPermissionsLfTagOutput) ToGetPermissionsLfTagPtrOutput() GetPermissionsLfTagPtrOutput {
	return o.ToGetPermissionsLfTagPtrOutputWithContext(context.Background())
}

func (o GetPermissionsLfTagOutput) ToGetPermissionsLfTagPtrOutputWithContext(ctx context.Context) GetPermissionsLfTagPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v GetPermissionsLfTag) *GetPermissionsLfTag {
		return &v
	}).(GetPermissionsLfTagPtrOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o GetPermissionsLfTagOutput) CatalogId() pulumi.StringOutput {
	return o.ApplyT(func(v GetPermissionsLfTag) string { return v.CatalogId }).(pulumi.StringOutput)
}

// Key-name for the tag.
func (o GetPermissionsLfTagOutput) Key() pulumi.StringOutput {
	return o.ApplyT(func(v GetPermissionsLfTag) string { return v.Key }).(pulumi.StringOutput)
}

// List of possible values an attribute can take.
//
// The following argument is optional:
func (o GetPermissionsLfTagOutput) Values() pulumi.StringArrayOutput {
	return o.ApplyT(func(v GetPermissionsLfTag) []string { return v.Values }).(pulumi.StringArrayOutput)
}

type GetPermissionsLfTagPtrOutput struct{ *pulumi.OutputState }

func (GetPermissionsLfTagPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**GetPermissionsLfTag)(nil)).Elem()
}

func (o GetPermissionsLfTagPtrOutput) ToGetPermissionsLfTagPtrOutput() GetPermissionsLfTagPtrOutput {
	return o
}

func (o GetPermissionsLfTagPtrOutput) ToGetPermissionsLfTagPtrOutputWithContext(ctx context.Context) GetPermissionsLfTagPtrOutput {
	return o
}

func (o GetPermissionsLfTagPtrOutput) Elem() GetPermissionsLfTagOutput {
	return o.ApplyT(func(v *GetPermissionsLfTag) GetPermissionsLfTag {
		if v != nil {
			return *v
		}
		var ret GetPermissionsLfTag
		return ret
	}).(GetPermissionsLfTagOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o GetPermissionsLfTagPtrOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *GetPermissionsLfTag) *string {
		if v == nil {
			return nil
		}
		return &v.CatalogId
	}).(pulumi.StringPtrOutput)
}

// Key-name for the tag.
func (o GetPermissionsLfTagPtrOutput) Key() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *GetPermissionsLfTag) *string {
		if v == nil {
			return nil
		}
		return &v.Key
	}).(pulumi.StringPtrOutput)
}

// List of possible values an attribute can take.
//
// The following argument is optional:
func (o GetPermissionsLfTagPtrOutput) Values() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *GetPermissionsLfTag) []string {
		if v == nil {
			return nil
		}
		return v.Values
	}).(pulumi.StringArrayOutput)
}

type GetPermissionsLfTagPolicy struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId string `pulumi:"catalogId"`
	// List of tag conditions that apply to the resource's tag policy. Configuration block for tag conditions that apply to the policy. See `expression` below.
	//
	// The following argument is optional:
	Expressions []GetPermissionsLfTagPolicyExpression `pulumi:"expressions"`
	// Resource type for which the tag policy applies. Valid values are `DATABASE` and `TABLE`.
	ResourceType string `pulumi:"resourceType"`
}

// GetPermissionsLfTagPolicyInput is an input type that accepts GetPermissionsLfTagPolicyArgs and GetPermissionsLfTagPolicyOutput values.
// You can construct a concrete instance of `GetPermissionsLfTagPolicyInput` via:
//
//	GetPermissionsLfTagPolicyArgs{...}
type GetPermissionsLfTagPolicyInput interface {
	pulumi.Input

	ToGetPermissionsLfTagPolicyOutput() GetPermissionsLfTagPolicyOutput
	ToGetPermissionsLfTagPolicyOutputWithContext(context.Context) GetPermissionsLfTagPolicyOutput
}

type GetPermissionsLfTagPolicyArgs struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId pulumi.StringInput `pulumi:"catalogId"`
	// List of tag conditions that apply to the resource's tag policy. Configuration block for tag conditions that apply to the policy. See `expression` below.
	//
	// The following argument is optional:
	Expressions GetPermissionsLfTagPolicyExpressionArrayInput `pulumi:"expressions"`
	// Resource type for which the tag policy applies. Valid values are `DATABASE` and `TABLE`.
	ResourceType pulumi.StringInput `pulumi:"resourceType"`
}

func (GetPermissionsLfTagPolicyArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPermissionsLfTagPolicy)(nil)).Elem()
}

func (i GetPermissionsLfTagPolicyArgs) ToGetPermissionsLfTagPolicyOutput() GetPermissionsLfTagPolicyOutput {
	return i.ToGetPermissionsLfTagPolicyOutputWithContext(context.Background())
}

func (i GetPermissionsLfTagPolicyArgs) ToGetPermissionsLfTagPolicyOutputWithContext(ctx context.Context) GetPermissionsLfTagPolicyOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPermissionsLfTagPolicyOutput)
}

func (i GetPermissionsLfTagPolicyArgs) ToGetPermissionsLfTagPolicyPtrOutput() GetPermissionsLfTagPolicyPtrOutput {
	return i.ToGetPermissionsLfTagPolicyPtrOutputWithContext(context.Background())
}

func (i GetPermissionsLfTagPolicyArgs) ToGetPermissionsLfTagPolicyPtrOutputWithContext(ctx context.Context) GetPermissionsLfTagPolicyPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPermissionsLfTagPolicyOutput).ToGetPermissionsLfTagPolicyPtrOutputWithContext(ctx)
}

// GetPermissionsLfTagPolicyPtrInput is an input type that accepts GetPermissionsLfTagPolicyArgs, GetPermissionsLfTagPolicyPtr and GetPermissionsLfTagPolicyPtrOutput values.
// You can construct a concrete instance of `GetPermissionsLfTagPolicyPtrInput` via:
//
//	        GetPermissionsLfTagPolicyArgs{...}
//
//	or:
//
//	        nil
type GetPermissionsLfTagPolicyPtrInput interface {
	pulumi.Input

	ToGetPermissionsLfTagPolicyPtrOutput() GetPermissionsLfTagPolicyPtrOutput
	ToGetPermissionsLfTagPolicyPtrOutputWithContext(context.Context) GetPermissionsLfTagPolicyPtrOutput
}

type getPermissionsLfTagPolicyPtrType GetPermissionsLfTagPolicyArgs

func GetPermissionsLfTagPolicyPtr(v *GetPermissionsLfTagPolicyArgs) GetPermissionsLfTagPolicyPtrInput {
	return (*getPermissionsLfTagPolicyPtrType)(v)
}

func (*getPermissionsLfTagPolicyPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**GetPermissionsLfTagPolicy)(nil)).Elem()
}

func (i *getPermissionsLfTagPolicyPtrType) ToGetPermissionsLfTagPolicyPtrOutput() GetPermissionsLfTagPolicyPtrOutput {
	return i.ToGetPermissionsLfTagPolicyPtrOutputWithContext(context.Background())
}

func (i *getPermissionsLfTagPolicyPtrType) ToGetPermissionsLfTagPolicyPtrOutputWithContext(ctx context.Context) GetPermissionsLfTagPolicyPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPermissionsLfTagPolicyPtrOutput)
}

type GetPermissionsLfTagPolicyOutput struct{ *pulumi.OutputState }

func (GetPermissionsLfTagPolicyOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPermissionsLfTagPolicy)(nil)).Elem()
}

func (o GetPermissionsLfTagPolicyOutput) ToGetPermissionsLfTagPolicyOutput() GetPermissionsLfTagPolicyOutput {
	return o
}

func (o GetPermissionsLfTagPolicyOutput) ToGetPermissionsLfTagPolicyOutputWithContext(ctx context.Context) GetPermissionsLfTagPolicyOutput {
	return o
}

func (o GetPermissionsLfTagPolicyOutput) ToGetPermissionsLfTagPolicyPtrOutput() GetPermissionsLfTagPolicyPtrOutput {
	return o.ToGetPermissionsLfTagPolicyPtrOutputWithContext(context.Background())
}

func (o GetPermissionsLfTagPolicyOutput) ToGetPermissionsLfTagPolicyPtrOutputWithContext(ctx context.Context) GetPermissionsLfTagPolicyPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v GetPermissionsLfTagPolicy) *GetPermissionsLfTagPolicy {
		return &v
	}).(GetPermissionsLfTagPolicyPtrOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o GetPermissionsLfTagPolicyOutput) CatalogId() pulumi.StringOutput {
	return o.ApplyT(func(v GetPermissionsLfTagPolicy) string { return v.CatalogId }).(pulumi.StringOutput)
}

// List of tag conditions that apply to the resource's tag policy. Configuration block for tag conditions that apply to the policy. See `expression` below.
//
// The following argument is optional:
func (o GetPermissionsLfTagPolicyOutput) Expressions() GetPermissionsLfTagPolicyExpressionArrayOutput {
	return o.ApplyT(func(v GetPermissionsLfTagPolicy) []GetPermissionsLfTagPolicyExpression { return v.Expressions }).(GetPermissionsLfTagPolicyExpressionArrayOutput)
}

// Resource type for which the tag policy applies. Valid values are `DATABASE` and `TABLE`.
func (o GetPermissionsLfTagPolicyOutput) ResourceType() pulumi.StringOutput {
	return o.ApplyT(func(v GetPermissionsLfTagPolicy) string { return v.ResourceType }).(pulumi.StringOutput)
}

type GetPermissionsLfTagPolicyPtrOutput struct{ *pulumi.OutputState }

func (GetPermissionsLfTagPolicyPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**GetPermissionsLfTagPolicy)(nil)).Elem()
}

func (o GetPermissionsLfTagPolicyPtrOutput) ToGetPermissionsLfTagPolicyPtrOutput() GetPermissionsLfTagPolicyPtrOutput {
	return o
}

func (o GetPermissionsLfTagPolicyPtrOutput) ToGetPermissionsLfTagPolicyPtrOutputWithContext(ctx context.Context) GetPermissionsLfTagPolicyPtrOutput {
	return o
}

func (o GetPermissionsLfTagPolicyPtrOutput) Elem() GetPermissionsLfTagPolicyOutput {
	return o.ApplyT(func(v *GetPermissionsLfTagPolicy) GetPermissionsLfTagPolicy {
		if v != nil {
			return *v
		}
		var ret GetPermissionsLfTagPolicy
		return ret
	}).(GetPermissionsLfTagPolicyOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o GetPermissionsLfTagPolicyPtrOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *GetPermissionsLfTagPolicy) *string {
		if v == nil {
			return nil
		}
		return &v.CatalogId
	}).(pulumi.StringPtrOutput)
}

// List of tag conditions that apply to the resource's tag policy. Configuration block for tag conditions that apply to the policy. See `expression` below.
//
// The following argument is optional:
func (o GetPermissionsLfTagPolicyPtrOutput) Expressions() GetPermissionsLfTagPolicyExpressionArrayOutput {
	return o.ApplyT(func(v *GetPermissionsLfTagPolicy) []GetPermissionsLfTagPolicyExpression {
		if v == nil {
			return nil
		}
		return v.Expressions
	}).(GetPermissionsLfTagPolicyExpressionArrayOutput)
}

// Resource type for which the tag policy applies. Valid values are `DATABASE` and `TABLE`.
func (o GetPermissionsLfTagPolicyPtrOutput) ResourceType() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *GetPermissionsLfTagPolicy) *string {
		if v == nil {
			return nil
		}
		return &v.ResourceType
	}).(pulumi.StringPtrOutput)
}

type GetPermissionsLfTagPolicyExpression struct {
	// Key-name of an LF-Tag.
	Key string `pulumi:"key"`
	// List of possible values of an LF-Tag.
	Values []string `pulumi:"values"`
}

// GetPermissionsLfTagPolicyExpressionInput is an input type that accepts GetPermissionsLfTagPolicyExpressionArgs and GetPermissionsLfTagPolicyExpressionOutput values.
// You can construct a concrete instance of `GetPermissionsLfTagPolicyExpressionInput` via:
//
//	GetPermissionsLfTagPolicyExpressionArgs{...}
type GetPermissionsLfTagPolicyExpressionInput interface {
	pulumi.Input

	ToGetPermissionsLfTagPolicyExpressionOutput() GetPermissionsLfTagPolicyExpressionOutput
	ToGetPermissionsLfTagPolicyExpressionOutputWithContext(context.Context) GetPermissionsLfTagPolicyExpressionOutput
}

type GetPermissionsLfTagPolicyExpressionArgs struct {
	// Key-name of an LF-Tag.
	Key pulumi.StringInput `pulumi:"key"`
	// List of possible values of an LF-Tag.
	Values pulumi.StringArrayInput `pulumi:"values"`
}

func (GetPermissionsLfTagPolicyExpressionArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPermissionsLfTagPolicyExpression)(nil)).Elem()
}

func (i GetPermissionsLfTagPolicyExpressionArgs) ToGetPermissionsLfTagPolicyExpressionOutput() GetPermissionsLfTagPolicyExpressionOutput {
	return i.ToGetPermissionsLfTagPolicyExpressionOutputWithContext(context.Background())
}

func (i GetPermissionsLfTagPolicyExpressionArgs) ToGetPermissionsLfTagPolicyExpressionOutputWithContext(ctx context.Context) GetPermissionsLfTagPolicyExpressionOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPermissionsLfTagPolicyExpressionOutput)
}

// GetPermissionsLfTagPolicyExpressionArrayInput is an input type that accepts GetPermissionsLfTagPolicyExpressionArray and GetPermissionsLfTagPolicyExpressionArrayOutput values.
// You can construct a concrete instance of `GetPermissionsLfTagPolicyExpressionArrayInput` via:
//
//	GetPermissionsLfTagPolicyExpressionArray{ GetPermissionsLfTagPolicyExpressionArgs{...} }
type GetPermissionsLfTagPolicyExpressionArrayInput interface {
	pulumi.Input

	ToGetPermissionsLfTagPolicyExpressionArrayOutput() GetPermissionsLfTagPolicyExpressionArrayOutput
	ToGetPermissionsLfTagPolicyExpressionArrayOutputWithContext(context.Context) GetPermissionsLfTagPolicyExpressionArrayOutput
}

type GetPermissionsLfTagPolicyExpressionArray []GetPermissionsLfTagPolicyExpressionInput

func (GetPermissionsLfTagPolicyExpressionArray) ElementType() reflect.Type {
	return reflect.TypeOf((*[]GetPermissionsLfTagPolicyExpression)(nil)).Elem()
}

func (i GetPermissionsLfTagPolicyExpressionArray) ToGetPermissionsLfTagPolicyExpressionArrayOutput() GetPermissionsLfTagPolicyExpressionArrayOutput {
	return i.ToGetPermissionsLfTagPolicyExpressionArrayOutputWithContext(context.Background())
}

func (i GetPermissionsLfTagPolicyExpressionArray) ToGetPermissionsLfTagPolicyExpressionArrayOutputWithContext(ctx context.Context) GetPermissionsLfTagPolicyExpressionArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPermissionsLfTagPolicyExpressionArrayOutput)
}

type GetPermissionsLfTagPolicyExpressionOutput struct{ *pulumi.OutputState }

func (GetPermissionsLfTagPolicyExpressionOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPermissionsLfTagPolicyExpression)(nil)).Elem()
}

func (o GetPermissionsLfTagPolicyExpressionOutput) ToGetPermissionsLfTagPolicyExpressionOutput() GetPermissionsLfTagPolicyExpressionOutput {
	return o
}

func (o GetPermissionsLfTagPolicyExpressionOutput) ToGetPermissionsLfTagPolicyExpressionOutputWithContext(ctx context.Context) GetPermissionsLfTagPolicyExpressionOutput {
	return o
}

// Key-name of an LF-Tag.
func (o GetPermissionsLfTagPolicyExpressionOutput) Key() pulumi.StringOutput {
	return o.ApplyT(func(v GetPermissionsLfTagPolicyExpression) string { return v.Key }).(pulumi.StringOutput)
}

// List of possible values of an LF-Tag.
func (o GetPermissionsLfTagPolicyExpressionOutput) Values() pulumi.StringArrayOutput {
	return o.ApplyT(func(v GetPermissionsLfTagPolicyExpression) []string { return v.Values }).(pulumi.StringArrayOutput)
}

type GetPermissionsLfTagPolicyExpressionArrayOutput struct{ *pulumi.OutputState }

func (GetPermissionsLfTagPolicyExpressionArrayOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*[]GetPermissionsLfTagPolicyExpression)(nil)).Elem()
}

func (o GetPermissionsLfTagPolicyExpressionArrayOutput) ToGetPermissionsLfTagPolicyExpressionArrayOutput() GetPermissionsLfTagPolicyExpressionArrayOutput {
	return o
}

func (o GetPermissionsLfTagPolicyExpressionArrayOutput) ToGetPermissionsLfTagPolicyExpressionArrayOutputWithContext(ctx context.Context) GetPermissionsLfTagPolicyExpressionArrayOutput {
	return o
}

func (o GetPermissionsLfTagPolicyExpressionArrayOutput) Index(i pulumi.IntInput) GetPermissionsLfTagPolicyExpressionOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetPermissionsLfTagPolicyExpression {
		return vs[0].([]GetPermissionsLfTagPolicyExpression)[vs[1].(int)]
	}).(GetPermissionsLfTagPolicyExpressionOutput)
}

type GetPermissionsTable struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId string `pulumi:"catalogId"`
	// Name of the database for the table. Unique to a Data Catalog.
	//
	// The following arguments are optional:
	DatabaseName string `pulumi:"databaseName"`
	// Name of the table. At least one of `name` or `wildcard` is required.
	Name string `pulumi:"name"`
	// Whether to use a wildcard representing every table under a database. At least one of `name` or `wildcard` is required. Defaults to `false`.
	Wildcard *bool `pulumi:"wildcard"`
}

// GetPermissionsTableInput is an input type that accepts GetPermissionsTableArgs and GetPermissionsTableOutput values.
// You can construct a concrete instance of `GetPermissionsTableInput` via:
//
//	GetPermissionsTableArgs{...}
type GetPermissionsTableInput interface {
	pulumi.Input

	ToGetPermissionsTableOutput() GetPermissionsTableOutput
	ToGetPermissionsTableOutputWithContext(context.Context) GetPermissionsTableOutput
}

type GetPermissionsTableArgs struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId pulumi.StringInput `pulumi:"catalogId"`
	// Name of the database for the table. Unique to a Data Catalog.
	//
	// The following arguments are optional:
	DatabaseName pulumi.StringInput `pulumi:"databaseName"`
	// Name of the table. At least one of `name` or `wildcard` is required.
	Name pulumi.StringInput `pulumi:"name"`
	// Whether to use a wildcard representing every table under a database. At least one of `name` or `wildcard` is required. Defaults to `false`.
	Wildcard pulumi.BoolPtrInput `pulumi:"wildcard"`
}

func (GetPermissionsTableArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPermissionsTable)(nil)).Elem()
}

func (i GetPermissionsTableArgs) ToGetPermissionsTableOutput() GetPermissionsTableOutput {
	return i.ToGetPermissionsTableOutputWithContext(context.Background())
}

func (i GetPermissionsTableArgs) ToGetPermissionsTableOutputWithContext(ctx context.Context) GetPermissionsTableOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPermissionsTableOutput)
}

func (i GetPermissionsTableArgs) ToGetPermissionsTablePtrOutput() GetPermissionsTablePtrOutput {
	return i.ToGetPermissionsTablePtrOutputWithContext(context.Background())
}

func (i GetPermissionsTableArgs) ToGetPermissionsTablePtrOutputWithContext(ctx context.Context) GetPermissionsTablePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPermissionsTableOutput).ToGetPermissionsTablePtrOutputWithContext(ctx)
}

// GetPermissionsTablePtrInput is an input type that accepts GetPermissionsTableArgs, GetPermissionsTablePtr and GetPermissionsTablePtrOutput values.
// You can construct a concrete instance of `GetPermissionsTablePtrInput` via:
//
//	        GetPermissionsTableArgs{...}
//
//	or:
//
//	        nil
type GetPermissionsTablePtrInput interface {
	pulumi.Input

	ToGetPermissionsTablePtrOutput() GetPermissionsTablePtrOutput
	ToGetPermissionsTablePtrOutputWithContext(context.Context) GetPermissionsTablePtrOutput
}

type getPermissionsTablePtrType GetPermissionsTableArgs

func GetPermissionsTablePtr(v *GetPermissionsTableArgs) GetPermissionsTablePtrInput {
	return (*getPermissionsTablePtrType)(v)
}

func (*getPermissionsTablePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**GetPermissionsTable)(nil)).Elem()
}

func (i *getPermissionsTablePtrType) ToGetPermissionsTablePtrOutput() GetPermissionsTablePtrOutput {
	return i.ToGetPermissionsTablePtrOutputWithContext(context.Background())
}

func (i *getPermissionsTablePtrType) ToGetPermissionsTablePtrOutputWithContext(ctx context.Context) GetPermissionsTablePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPermissionsTablePtrOutput)
}

type GetPermissionsTableOutput struct{ *pulumi.OutputState }

func (GetPermissionsTableOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPermissionsTable)(nil)).Elem()
}

func (o GetPermissionsTableOutput) ToGetPermissionsTableOutput() GetPermissionsTableOutput {
	return o
}

func (o GetPermissionsTableOutput) ToGetPermissionsTableOutputWithContext(ctx context.Context) GetPermissionsTableOutput {
	return o
}

func (o GetPermissionsTableOutput) ToGetPermissionsTablePtrOutput() GetPermissionsTablePtrOutput {
	return o.ToGetPermissionsTablePtrOutputWithContext(context.Background())
}

func (o GetPermissionsTableOutput) ToGetPermissionsTablePtrOutputWithContext(ctx context.Context) GetPermissionsTablePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v GetPermissionsTable) *GetPermissionsTable {
		return &v
	}).(GetPermissionsTablePtrOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o GetPermissionsTableOutput) CatalogId() pulumi.StringOutput {
	return o.ApplyT(func(v GetPermissionsTable) string { return v.CatalogId }).(pulumi.StringOutput)
}

// Name of the database for the table. Unique to a Data Catalog.
//
// The following arguments are optional:
func (o GetPermissionsTableOutput) DatabaseName() pulumi.StringOutput {
	return o.ApplyT(func(v GetPermissionsTable) string { return v.DatabaseName }).(pulumi.StringOutput)
}

// Name of the table. At least one of `name` or `wildcard` is required.
func (o GetPermissionsTableOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v GetPermissionsTable) string { return v.Name }).(pulumi.StringOutput)
}

// Whether to use a wildcard representing every table under a database. At least one of `name` or `wildcard` is required. Defaults to `false`.
func (o GetPermissionsTableOutput) Wildcard() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v GetPermissionsTable) *bool { return v.Wildcard }).(pulumi.BoolPtrOutput)
}

type GetPermissionsTablePtrOutput struct{ *pulumi.OutputState }

func (GetPermissionsTablePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**GetPermissionsTable)(nil)).Elem()
}

func (o GetPermissionsTablePtrOutput) ToGetPermissionsTablePtrOutput() GetPermissionsTablePtrOutput {
	return o
}

func (o GetPermissionsTablePtrOutput) ToGetPermissionsTablePtrOutputWithContext(ctx context.Context) GetPermissionsTablePtrOutput {
	return o
}

func (o GetPermissionsTablePtrOutput) Elem() GetPermissionsTableOutput {
	return o.ApplyT(func(v *GetPermissionsTable) GetPermissionsTable {
		if v != nil {
			return *v
		}
		var ret GetPermissionsTable
		return ret
	}).(GetPermissionsTableOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o GetPermissionsTablePtrOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *GetPermissionsTable) *string {
		if v == nil {
			return nil
		}
		return &v.CatalogId
	}).(pulumi.StringPtrOutput)
}

// Name of the database for the table. Unique to a Data Catalog.
//
// The following arguments are optional:
func (o GetPermissionsTablePtrOutput) DatabaseName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *GetPermissionsTable) *string {
		if v == nil {
			return nil
		}
		return &v.DatabaseName
	}).(pulumi.StringPtrOutput)
}

// Name of the table. At least one of `name` or `wildcard` is required.
func (o GetPermissionsTablePtrOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *GetPermissionsTable) *string {
		if v == nil {
			return nil
		}
		return &v.Name
	}).(pulumi.StringPtrOutput)
}

// Whether to use a wildcard representing every table under a database. At least one of `name` or `wildcard` is required. Defaults to `false`.
func (o GetPermissionsTablePtrOutput) Wildcard() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *GetPermissionsTable) *bool {
		if v == nil {
			return nil
		}
		return v.Wildcard
	}).(pulumi.BoolPtrOutput)
}

type GetPermissionsTableWithColumns struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId string `pulumi:"catalogId"`
	// Set of column names for the table. At least one of `columnNames` or `excludedColumnNames` is required.
	ColumnNames []string `pulumi:"columnNames"`
	// Name of the database for the table with columns resource. Unique to the Data Catalog.
	DatabaseName string `pulumi:"databaseName"`
	// Set of column names for the table to exclude. At least one of `columnNames` or `excludedColumnNames` is required.
	ExcludedColumnNames []string `pulumi:"excludedColumnNames"`
	// Name of the table resource.
	//
	// The following arguments are optional:
	Name string `pulumi:"name"`
	// Whether to use a wildcard representing every table under a database. At least one of `name` or `wildcard` is required. Defaults to `false`.
	Wildcard *bool `pulumi:"wildcard"`
}

// GetPermissionsTableWithColumnsInput is an input type that accepts GetPermissionsTableWithColumnsArgs and GetPermissionsTableWithColumnsOutput values.
// You can construct a concrete instance of `GetPermissionsTableWithColumnsInput` via:
//
//	GetPermissionsTableWithColumnsArgs{...}
type GetPermissionsTableWithColumnsInput interface {
	pulumi.Input

	ToGetPermissionsTableWithColumnsOutput() GetPermissionsTableWithColumnsOutput
	ToGetPermissionsTableWithColumnsOutputWithContext(context.Context) GetPermissionsTableWithColumnsOutput
}

type GetPermissionsTableWithColumnsArgs struct {
	// Identifier for the Data Catalog. By default, it is the account ID of the caller.
	CatalogId pulumi.StringInput `pulumi:"catalogId"`
	// Set of column names for the table. At least one of `columnNames` or `excludedColumnNames` is required.
	ColumnNames pulumi.StringArrayInput `pulumi:"columnNames"`
	// Name of the database for the table with columns resource. Unique to the Data Catalog.
	DatabaseName pulumi.StringInput `pulumi:"databaseName"`
	// Set of column names for the table to exclude. At least one of `columnNames` or `excludedColumnNames` is required.
	ExcludedColumnNames pulumi.StringArrayInput `pulumi:"excludedColumnNames"`
	// Name of the table resource.
	//
	// The following arguments are optional:
	Name pulumi.StringInput `pulumi:"name"`
	// Whether to use a wildcard representing every table under a database. At least one of `name` or `wildcard` is required. Defaults to `false`.
	Wildcard pulumi.BoolPtrInput `pulumi:"wildcard"`
}

func (GetPermissionsTableWithColumnsArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPermissionsTableWithColumns)(nil)).Elem()
}

func (i GetPermissionsTableWithColumnsArgs) ToGetPermissionsTableWithColumnsOutput() GetPermissionsTableWithColumnsOutput {
	return i.ToGetPermissionsTableWithColumnsOutputWithContext(context.Background())
}

func (i GetPermissionsTableWithColumnsArgs) ToGetPermissionsTableWithColumnsOutputWithContext(ctx context.Context) GetPermissionsTableWithColumnsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPermissionsTableWithColumnsOutput)
}

func (i GetPermissionsTableWithColumnsArgs) ToGetPermissionsTableWithColumnsPtrOutput() GetPermissionsTableWithColumnsPtrOutput {
	return i.ToGetPermissionsTableWithColumnsPtrOutputWithContext(context.Background())
}

func (i GetPermissionsTableWithColumnsArgs) ToGetPermissionsTableWithColumnsPtrOutputWithContext(ctx context.Context) GetPermissionsTableWithColumnsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPermissionsTableWithColumnsOutput).ToGetPermissionsTableWithColumnsPtrOutputWithContext(ctx)
}

// GetPermissionsTableWithColumnsPtrInput is an input type that accepts GetPermissionsTableWithColumnsArgs, GetPermissionsTableWithColumnsPtr and GetPermissionsTableWithColumnsPtrOutput values.
// You can construct a concrete instance of `GetPermissionsTableWithColumnsPtrInput` via:
//
//	        GetPermissionsTableWithColumnsArgs{...}
//
//	or:
//
//	        nil
type GetPermissionsTableWithColumnsPtrInput interface {
	pulumi.Input

	ToGetPermissionsTableWithColumnsPtrOutput() GetPermissionsTableWithColumnsPtrOutput
	ToGetPermissionsTableWithColumnsPtrOutputWithContext(context.Context) GetPermissionsTableWithColumnsPtrOutput
}

type getPermissionsTableWithColumnsPtrType GetPermissionsTableWithColumnsArgs

func GetPermissionsTableWithColumnsPtr(v *GetPermissionsTableWithColumnsArgs) GetPermissionsTableWithColumnsPtrInput {
	return (*getPermissionsTableWithColumnsPtrType)(v)
}

func (*getPermissionsTableWithColumnsPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**GetPermissionsTableWithColumns)(nil)).Elem()
}

func (i *getPermissionsTableWithColumnsPtrType) ToGetPermissionsTableWithColumnsPtrOutput() GetPermissionsTableWithColumnsPtrOutput {
	return i.ToGetPermissionsTableWithColumnsPtrOutputWithContext(context.Background())
}

func (i *getPermissionsTableWithColumnsPtrType) ToGetPermissionsTableWithColumnsPtrOutputWithContext(ctx context.Context) GetPermissionsTableWithColumnsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(GetPermissionsTableWithColumnsPtrOutput)
}

type GetPermissionsTableWithColumnsOutput struct{ *pulumi.OutputState }

func (GetPermissionsTableWithColumnsOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*GetPermissionsTableWithColumns)(nil)).Elem()
}

func (o GetPermissionsTableWithColumnsOutput) ToGetPermissionsTableWithColumnsOutput() GetPermissionsTableWithColumnsOutput {
	return o
}

func (o GetPermissionsTableWithColumnsOutput) ToGetPermissionsTableWithColumnsOutputWithContext(ctx context.Context) GetPermissionsTableWithColumnsOutput {
	return o
}

func (o GetPermissionsTableWithColumnsOutput) ToGetPermissionsTableWithColumnsPtrOutput() GetPermissionsTableWithColumnsPtrOutput {
	return o.ToGetPermissionsTableWithColumnsPtrOutputWithContext(context.Background())
}

func (o GetPermissionsTableWithColumnsOutput) ToGetPermissionsTableWithColumnsPtrOutputWithContext(ctx context.Context) GetPermissionsTableWithColumnsPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v GetPermissionsTableWithColumns) *GetPermissionsTableWithColumns {
		return &v
	}).(GetPermissionsTableWithColumnsPtrOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o GetPermissionsTableWithColumnsOutput) CatalogId() pulumi.StringOutput {
	return o.ApplyT(func(v GetPermissionsTableWithColumns) string { return v.CatalogId }).(pulumi.StringOutput)
}

// Set of column names for the table. At least one of `columnNames` or `excludedColumnNames` is required.
func (o GetPermissionsTableWithColumnsOutput) ColumnNames() pulumi.StringArrayOutput {
	return o.ApplyT(func(v GetPermissionsTableWithColumns) []string { return v.ColumnNames }).(pulumi.StringArrayOutput)
}

// Name of the database for the table with columns resource. Unique to the Data Catalog.
func (o GetPermissionsTableWithColumnsOutput) DatabaseName() pulumi.StringOutput {
	return o.ApplyT(func(v GetPermissionsTableWithColumns) string { return v.DatabaseName }).(pulumi.StringOutput)
}

// Set of column names for the table to exclude. At least one of `columnNames` or `excludedColumnNames` is required.
func (o GetPermissionsTableWithColumnsOutput) ExcludedColumnNames() pulumi.StringArrayOutput {
	return o.ApplyT(func(v GetPermissionsTableWithColumns) []string { return v.ExcludedColumnNames }).(pulumi.StringArrayOutput)
}

// Name of the table resource.
//
// The following arguments are optional:
func (o GetPermissionsTableWithColumnsOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v GetPermissionsTableWithColumns) string { return v.Name }).(pulumi.StringOutput)
}

// Whether to use a wildcard representing every table under a database. At least one of `name` or `wildcard` is required. Defaults to `false`.
func (o GetPermissionsTableWithColumnsOutput) Wildcard() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v GetPermissionsTableWithColumns) *bool { return v.Wildcard }).(pulumi.BoolPtrOutput)
}

type GetPermissionsTableWithColumnsPtrOutput struct{ *pulumi.OutputState }

func (GetPermissionsTableWithColumnsPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**GetPermissionsTableWithColumns)(nil)).Elem()
}

func (o GetPermissionsTableWithColumnsPtrOutput) ToGetPermissionsTableWithColumnsPtrOutput() GetPermissionsTableWithColumnsPtrOutput {
	return o
}

func (o GetPermissionsTableWithColumnsPtrOutput) ToGetPermissionsTableWithColumnsPtrOutputWithContext(ctx context.Context) GetPermissionsTableWithColumnsPtrOutput {
	return o
}

func (o GetPermissionsTableWithColumnsPtrOutput) Elem() GetPermissionsTableWithColumnsOutput {
	return o.ApplyT(func(v *GetPermissionsTableWithColumns) GetPermissionsTableWithColumns {
		if v != nil {
			return *v
		}
		var ret GetPermissionsTableWithColumns
		return ret
	}).(GetPermissionsTableWithColumnsOutput)
}

// Identifier for the Data Catalog. By default, it is the account ID of the caller.
func (o GetPermissionsTableWithColumnsPtrOutput) CatalogId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *GetPermissionsTableWithColumns) *string {
		if v == nil {
			return nil
		}
		return &v.CatalogId
	}).(pulumi.StringPtrOutput)
}

// Set of column names for the table. At least one of `columnNames` or `excludedColumnNames` is required.
func (o GetPermissionsTableWithColumnsPtrOutput) ColumnNames() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *GetPermissionsTableWithColumns) []string {
		if v == nil {
			return nil
		}
		return v.ColumnNames
	}).(pulumi.StringArrayOutput)
}

// Name of the database for the table with columns resource. Unique to the Data Catalog.
func (o GetPermissionsTableWithColumnsPtrOutput) DatabaseName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *GetPermissionsTableWithColumns) *string {
		if v == nil {
			return nil
		}
		return &v.DatabaseName
	}).(pulumi.StringPtrOutput)
}

// Set of column names for the table to exclude. At least one of `columnNames` or `excludedColumnNames` is required.
func (o GetPermissionsTableWithColumnsPtrOutput) ExcludedColumnNames() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *GetPermissionsTableWithColumns) []string {
		if v == nil {
			return nil
		}
		return v.ExcludedColumnNames
	}).(pulumi.StringArrayOutput)
}

// Name of the table resource.
//
// The following arguments are optional:
func (o GetPermissionsTableWithColumnsPtrOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *GetPermissionsTableWithColumns) *string {
		if v == nil {
			return nil
		}
		return &v.Name
	}).(pulumi.StringPtrOutput)
}

// Whether to use a wildcard representing every table under a database. At least one of `name` or `wildcard` is required. Defaults to `false`.
func (o GetPermissionsTableWithColumnsPtrOutput) Wildcard() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *GetPermissionsTableWithColumns) *bool {
		if v == nil {
			return nil
		}
		return v.Wildcard
	}).(pulumi.BoolPtrOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*DataCellsFilterTableDataInput)(nil)).Elem(), DataCellsFilterTableDataArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*DataCellsFilterTableDataPtrInput)(nil)).Elem(), DataCellsFilterTableDataArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*DataCellsFilterTableDataColumnWildcardInput)(nil)).Elem(), DataCellsFilterTableDataColumnWildcardArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*DataCellsFilterTableDataColumnWildcardPtrInput)(nil)).Elem(), DataCellsFilterTableDataColumnWildcardArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*DataCellsFilterTableDataRowFilterInput)(nil)).Elem(), DataCellsFilterTableDataRowFilterArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*DataCellsFilterTableDataRowFilterPtrInput)(nil)).Elem(), DataCellsFilterTableDataRowFilterArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*DataCellsFilterTableDataRowFilterAllRowsWildcardInput)(nil)).Elem(), DataCellsFilterTableDataRowFilterAllRowsWildcardArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*DataCellsFilterTableDataRowFilterAllRowsWildcardPtrInput)(nil)).Elem(), DataCellsFilterTableDataRowFilterAllRowsWildcardArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*DataCellsFilterTimeoutsInput)(nil)).Elem(), DataCellsFilterTimeoutsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*DataCellsFilterTimeoutsPtrInput)(nil)).Elem(), DataCellsFilterTimeoutsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*DataLakeSettingsCreateDatabaseDefaultPermissionInput)(nil)).Elem(), DataLakeSettingsCreateDatabaseDefaultPermissionArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*DataLakeSettingsCreateDatabaseDefaultPermissionArrayInput)(nil)).Elem(), DataLakeSettingsCreateDatabaseDefaultPermissionArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*DataLakeSettingsCreateTableDefaultPermissionInput)(nil)).Elem(), DataLakeSettingsCreateTableDefaultPermissionArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*DataLakeSettingsCreateTableDefaultPermissionArrayInput)(nil)).Elem(), DataLakeSettingsCreateTableDefaultPermissionArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*PermissionsDataCellsFilterInput)(nil)).Elem(), PermissionsDataCellsFilterArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PermissionsDataCellsFilterPtrInput)(nil)).Elem(), PermissionsDataCellsFilterArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PermissionsDataLocationInput)(nil)).Elem(), PermissionsDataLocationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PermissionsDataLocationPtrInput)(nil)).Elem(), PermissionsDataLocationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PermissionsDatabaseInput)(nil)).Elem(), PermissionsDatabaseArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PermissionsDatabasePtrInput)(nil)).Elem(), PermissionsDatabaseArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PermissionsLfTagInput)(nil)).Elem(), PermissionsLfTagArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PermissionsLfTagPtrInput)(nil)).Elem(), PermissionsLfTagArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PermissionsLfTagPolicyInput)(nil)).Elem(), PermissionsLfTagPolicyArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PermissionsLfTagPolicyPtrInput)(nil)).Elem(), PermissionsLfTagPolicyArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PermissionsLfTagPolicyExpressionInput)(nil)).Elem(), PermissionsLfTagPolicyExpressionArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PermissionsLfTagPolicyExpressionArrayInput)(nil)).Elem(), PermissionsLfTagPolicyExpressionArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*PermissionsTableInput)(nil)).Elem(), PermissionsTableArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PermissionsTablePtrInput)(nil)).Elem(), PermissionsTableArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PermissionsTableWithColumnsInput)(nil)).Elem(), PermissionsTableWithColumnsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*PermissionsTableWithColumnsPtrInput)(nil)).Elem(), PermissionsTableWithColumnsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceLfTagDatabaseInput)(nil)).Elem(), ResourceLfTagDatabaseArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceLfTagDatabasePtrInput)(nil)).Elem(), ResourceLfTagDatabaseArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceLfTagLfTagInput)(nil)).Elem(), ResourceLfTagLfTagArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceLfTagLfTagPtrInput)(nil)).Elem(), ResourceLfTagLfTagArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceLfTagTableInput)(nil)).Elem(), ResourceLfTagTableArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceLfTagTablePtrInput)(nil)).Elem(), ResourceLfTagTableArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceLfTagTableWithColumnsInput)(nil)).Elem(), ResourceLfTagTableWithColumnsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceLfTagTableWithColumnsPtrInput)(nil)).Elem(), ResourceLfTagTableWithColumnsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceLfTagTableWithColumnsColumnWildcardInput)(nil)).Elem(), ResourceLfTagTableWithColumnsColumnWildcardArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceLfTagTableWithColumnsColumnWildcardPtrInput)(nil)).Elem(), ResourceLfTagTableWithColumnsColumnWildcardArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceLfTagTimeoutsInput)(nil)).Elem(), ResourceLfTagTimeoutsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceLfTagTimeoutsPtrInput)(nil)).Elem(), ResourceLfTagTimeoutsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceLfTagsDatabaseInput)(nil)).Elem(), ResourceLfTagsDatabaseArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceLfTagsDatabasePtrInput)(nil)).Elem(), ResourceLfTagsDatabaseArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceLfTagsLfTagInput)(nil)).Elem(), ResourceLfTagsLfTagArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceLfTagsLfTagArrayInput)(nil)).Elem(), ResourceLfTagsLfTagArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceLfTagsTableInput)(nil)).Elem(), ResourceLfTagsTableArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceLfTagsTablePtrInput)(nil)).Elem(), ResourceLfTagsTableArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceLfTagsTableWithColumnsInput)(nil)).Elem(), ResourceLfTagsTableWithColumnsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*ResourceLfTagsTableWithColumnsPtrInput)(nil)).Elem(), ResourceLfTagsTableWithColumnsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetDataLakeSettingsCreateDatabaseDefaultPermissionInput)(nil)).Elem(), GetDataLakeSettingsCreateDatabaseDefaultPermissionArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetDataLakeSettingsCreateDatabaseDefaultPermissionArrayInput)(nil)).Elem(), GetDataLakeSettingsCreateDatabaseDefaultPermissionArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetDataLakeSettingsCreateTableDefaultPermissionInput)(nil)).Elem(), GetDataLakeSettingsCreateTableDefaultPermissionArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetDataLakeSettingsCreateTableDefaultPermissionArrayInput)(nil)).Elem(), GetDataLakeSettingsCreateTableDefaultPermissionArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetPermissionsDataCellsFilterInput)(nil)).Elem(), GetPermissionsDataCellsFilterArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetPermissionsDataCellsFilterPtrInput)(nil)).Elem(), GetPermissionsDataCellsFilterArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetPermissionsDataLocationInput)(nil)).Elem(), GetPermissionsDataLocationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetPermissionsDataLocationPtrInput)(nil)).Elem(), GetPermissionsDataLocationArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetPermissionsDatabaseInput)(nil)).Elem(), GetPermissionsDatabaseArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetPermissionsDatabasePtrInput)(nil)).Elem(), GetPermissionsDatabaseArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetPermissionsLfTagInput)(nil)).Elem(), GetPermissionsLfTagArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetPermissionsLfTagPtrInput)(nil)).Elem(), GetPermissionsLfTagArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetPermissionsLfTagPolicyInput)(nil)).Elem(), GetPermissionsLfTagPolicyArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetPermissionsLfTagPolicyPtrInput)(nil)).Elem(), GetPermissionsLfTagPolicyArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetPermissionsLfTagPolicyExpressionInput)(nil)).Elem(), GetPermissionsLfTagPolicyExpressionArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetPermissionsLfTagPolicyExpressionArrayInput)(nil)).Elem(), GetPermissionsLfTagPolicyExpressionArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetPermissionsTableInput)(nil)).Elem(), GetPermissionsTableArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetPermissionsTablePtrInput)(nil)).Elem(), GetPermissionsTableArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetPermissionsTableWithColumnsInput)(nil)).Elem(), GetPermissionsTableWithColumnsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*GetPermissionsTableWithColumnsPtrInput)(nil)).Elem(), GetPermissionsTableWithColumnsArgs{})
	pulumi.RegisterOutputType(DataCellsFilterTableDataOutput{})
	pulumi.RegisterOutputType(DataCellsFilterTableDataPtrOutput{})
	pulumi.RegisterOutputType(DataCellsFilterTableDataColumnWildcardOutput{})
	pulumi.RegisterOutputType(DataCellsFilterTableDataColumnWildcardPtrOutput{})
	pulumi.RegisterOutputType(DataCellsFilterTableDataRowFilterOutput{})
	pulumi.RegisterOutputType(DataCellsFilterTableDataRowFilterPtrOutput{})
	pulumi.RegisterOutputType(DataCellsFilterTableDataRowFilterAllRowsWildcardOutput{})
	pulumi.RegisterOutputType(DataCellsFilterTableDataRowFilterAllRowsWildcardPtrOutput{})
	pulumi.RegisterOutputType(DataCellsFilterTimeoutsOutput{})
	pulumi.RegisterOutputType(DataCellsFilterTimeoutsPtrOutput{})
	pulumi.RegisterOutputType(DataLakeSettingsCreateDatabaseDefaultPermissionOutput{})
	pulumi.RegisterOutputType(DataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput{})
	pulumi.RegisterOutputType(DataLakeSettingsCreateTableDefaultPermissionOutput{})
	pulumi.RegisterOutputType(DataLakeSettingsCreateTableDefaultPermissionArrayOutput{})
	pulumi.RegisterOutputType(PermissionsDataCellsFilterOutput{})
	pulumi.RegisterOutputType(PermissionsDataCellsFilterPtrOutput{})
	pulumi.RegisterOutputType(PermissionsDataLocationOutput{})
	pulumi.RegisterOutputType(PermissionsDataLocationPtrOutput{})
	pulumi.RegisterOutputType(PermissionsDatabaseOutput{})
	pulumi.RegisterOutputType(PermissionsDatabasePtrOutput{})
	pulumi.RegisterOutputType(PermissionsLfTagOutput{})
	pulumi.RegisterOutputType(PermissionsLfTagPtrOutput{})
	pulumi.RegisterOutputType(PermissionsLfTagPolicyOutput{})
	pulumi.RegisterOutputType(PermissionsLfTagPolicyPtrOutput{})
	pulumi.RegisterOutputType(PermissionsLfTagPolicyExpressionOutput{})
	pulumi.RegisterOutputType(PermissionsLfTagPolicyExpressionArrayOutput{})
	pulumi.RegisterOutputType(PermissionsTableOutput{})
	pulumi.RegisterOutputType(PermissionsTablePtrOutput{})
	pulumi.RegisterOutputType(PermissionsTableWithColumnsOutput{})
	pulumi.RegisterOutputType(PermissionsTableWithColumnsPtrOutput{})
	pulumi.RegisterOutputType(ResourceLfTagDatabaseOutput{})
	pulumi.RegisterOutputType(ResourceLfTagDatabasePtrOutput{})
	pulumi.RegisterOutputType(ResourceLfTagLfTagOutput{})
	pulumi.RegisterOutputType(ResourceLfTagLfTagPtrOutput{})
	pulumi.RegisterOutputType(ResourceLfTagTableOutput{})
	pulumi.RegisterOutputType(ResourceLfTagTablePtrOutput{})
	pulumi.RegisterOutputType(ResourceLfTagTableWithColumnsOutput{})
	pulumi.RegisterOutputType(ResourceLfTagTableWithColumnsPtrOutput{})
	pulumi.RegisterOutputType(ResourceLfTagTableWithColumnsColumnWildcardOutput{})
	pulumi.RegisterOutputType(ResourceLfTagTableWithColumnsColumnWildcardPtrOutput{})
	pulumi.RegisterOutputType(ResourceLfTagTimeoutsOutput{})
	pulumi.RegisterOutputType(ResourceLfTagTimeoutsPtrOutput{})
	pulumi.RegisterOutputType(ResourceLfTagsDatabaseOutput{})
	pulumi.RegisterOutputType(ResourceLfTagsDatabasePtrOutput{})
	pulumi.RegisterOutputType(ResourceLfTagsLfTagOutput{})
	pulumi.RegisterOutputType(ResourceLfTagsLfTagArrayOutput{})
	pulumi.RegisterOutputType(ResourceLfTagsTableOutput{})
	pulumi.RegisterOutputType(ResourceLfTagsTablePtrOutput{})
	pulumi.RegisterOutputType(ResourceLfTagsTableWithColumnsOutput{})
	pulumi.RegisterOutputType(ResourceLfTagsTableWithColumnsPtrOutput{})
	pulumi.RegisterOutputType(GetDataLakeSettingsCreateDatabaseDefaultPermissionOutput{})
	pulumi.RegisterOutputType(GetDataLakeSettingsCreateDatabaseDefaultPermissionArrayOutput{})
	pulumi.RegisterOutputType(GetDataLakeSettingsCreateTableDefaultPermissionOutput{})
	pulumi.RegisterOutputType(GetDataLakeSettingsCreateTableDefaultPermissionArrayOutput{})
	pulumi.RegisterOutputType(GetPermissionsDataCellsFilterOutput{})
	pulumi.RegisterOutputType(GetPermissionsDataCellsFilterPtrOutput{})
	pulumi.RegisterOutputType(GetPermissionsDataLocationOutput{})
	pulumi.RegisterOutputType(GetPermissionsDataLocationPtrOutput{})
	pulumi.RegisterOutputType(GetPermissionsDatabaseOutput{})
	pulumi.RegisterOutputType(GetPermissionsDatabasePtrOutput{})
	pulumi.RegisterOutputType(GetPermissionsLfTagOutput{})
	pulumi.RegisterOutputType(GetPermissionsLfTagPtrOutput{})
	pulumi.RegisterOutputType(GetPermissionsLfTagPolicyOutput{})
	pulumi.RegisterOutputType(GetPermissionsLfTagPolicyPtrOutput{})
	pulumi.RegisterOutputType(GetPermissionsLfTagPolicyExpressionOutput{})
	pulumi.RegisterOutputType(GetPermissionsLfTagPolicyExpressionArrayOutput{})
	pulumi.RegisterOutputType(GetPermissionsTableOutput{})
	pulumi.RegisterOutputType(GetPermissionsTablePtrOutput{})
	pulumi.RegisterOutputType(GetPermissionsTableWithColumnsOutput{})
	pulumi.RegisterOutputType(GetPermissionsTableWithColumnsPtrOutput{})
}