v1

package
v0.3.0 Latest Latest
Warning

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

 Go to latest Published: Jun 9, 2021 License: Apache-2.0 Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AuditConfig 

type AuditConfig struct {
	// The configuration for logging of each type of permission.
	AuditLogConfigs []AuditLogConfig `pulumi:"auditLogConfigs"`
	ExemptedMembers []string         `pulumi:"exemptedMembers"`
	// Specifies a service that will be enabled for audit logging. For example, `storage.googleapis.com`, `cloudsql.googleapis.com`. `allServices` is a special value that covers all services.
	Service *string `pulumi:"service"`
}

Specifies the audit configuration for a service. The configuration determines which permission types are logged, and what identities, if any, are exempted from logging. An AuditConfig must have one or more AuditLogConfigs. If there are AuditConfigs for both `allServices` and a specific service, the union of the two AuditConfigs is used for that service: the log_types specified in each AuditConfig are enabled, and the exempted_members in each AuditLogConfig are exempted. Example Policy with multiple AuditConfigs: { "audit_configs": [ { "service": "allServices", "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] }, { "log_type": "DATA_WRITE" }, { "log_type": "ADMIN_READ" } ] }, { "service": "sampleservice.googleapis.com", "audit_log_configs": [ { "log_type": "DATA_READ" }, { "log_type": "DATA_WRITE", "exempted_members": [ "user:aliya@example.com" ] } ] } ] } For sampleservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ logging. It also exempts jose@example.com from DATA_READ logging, and aliya@example.com from DATA_WRITE logging.

type AuditConfigArgs 

type AuditConfigArgs struct {
	// The configuration for logging of each type of permission.
	AuditLogConfigs AuditLogConfigArrayInput `pulumi:"auditLogConfigs"`
	ExemptedMembers pulumi.StringArrayInput  `pulumi:"exemptedMembers"`
	// Specifies a service that will be enabled for audit logging. For example, `storage.googleapis.com`, `cloudsql.googleapis.com`. `allServices` is a special value that covers all services.
	Service pulumi.StringPtrInput `pulumi:"service"`
}

Specifies the audit configuration for a service. The configuration determines which permission types are logged, and what identities, if any, are exempted from logging. An AuditConfig must have one or more AuditLogConfigs. If there are AuditConfigs for both `allServices` and a specific service, the union of the two AuditConfigs is used for that service: the log_types specified in each AuditConfig are enabled, and the exempted_members in each AuditLogConfig are exempted. Example Policy with multiple AuditConfigs: { "audit_configs": [ { "service": "allServices", "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] }, { "log_type": "DATA_WRITE" }, { "log_type": "ADMIN_READ" } ] }, { "service": "sampleservice.googleapis.com", "audit_log_configs": [ { "log_type": "DATA_READ" }, { "log_type": "DATA_WRITE", "exempted_members": [ "user:aliya@example.com" ] } ] } ] } For sampleservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ logging. It also exempts jose@example.com from DATA_READ logging, and aliya@example.com from DATA_WRITE logging.

func (AuditConfigArgs) ElementType 

func (AuditConfigArgs) ElementType() reflect.Type

func (AuditConfigArgs) ToAuditConfigOutput 

func (i AuditConfigArgs) ToAuditConfigOutput() AuditConfigOutput

func (AuditConfigArgs) ToAuditConfigOutputWithContext 

func (i AuditConfigArgs) ToAuditConfigOutputWithContext(ctx context.Context) AuditConfigOutput

type AuditConfigArray 

type AuditConfigArray []AuditConfigInput

func (AuditConfigArray) ElementType 

func (AuditConfigArray) ElementType() reflect.Type

func (AuditConfigArray) ToAuditConfigArrayOutput 

func (i AuditConfigArray) ToAuditConfigArrayOutput() AuditConfigArrayOutput

func (AuditConfigArray) ToAuditConfigArrayOutputWithContext 

func (i AuditConfigArray) ToAuditConfigArrayOutputWithContext(ctx context.Context) AuditConfigArrayOutput

type AuditConfigArrayInput 

type AuditConfigArrayInput interface {
	pulumi.Input

	ToAuditConfigArrayOutput() AuditConfigArrayOutput
	ToAuditConfigArrayOutputWithContext(context.Context) AuditConfigArrayOutput
}

AuditConfigArrayInput is an input type that accepts AuditConfigArray and AuditConfigArrayOutput values. You can construct a concrete instance of `AuditConfigArrayInput` via: 

AuditConfigArray{ AuditConfigArgs{...} }

type AuditConfigArrayOutput 

type AuditConfigArrayOutput struct{ *pulumi.OutputState }

func (AuditConfigArrayOutput) ElementType 

func (AuditConfigArrayOutput) ElementType() reflect.Type

func (AuditConfigArrayOutput) Index 

func (o AuditConfigArrayOutput) Index(i pulumi.IntInput) AuditConfigOutput

func (AuditConfigArrayOutput) ToAuditConfigArrayOutput 

func (o AuditConfigArrayOutput) ToAuditConfigArrayOutput() AuditConfigArrayOutput

func (AuditConfigArrayOutput) ToAuditConfigArrayOutputWithContext 

func (o AuditConfigArrayOutput) ToAuditConfigArrayOutputWithContext(ctx context.Context) AuditConfigArrayOutput

type AuditConfigInput 

type AuditConfigInput interface {
	pulumi.Input

	ToAuditConfigOutput() AuditConfigOutput
	ToAuditConfigOutputWithContext(context.Context) AuditConfigOutput
}

AuditConfigInput is an input type that accepts AuditConfigArgs and AuditConfigOutput values. You can construct a concrete instance of `AuditConfigInput` via: 

AuditConfigArgs{...}

type AuditConfigOutput 

type AuditConfigOutput struct{ *pulumi.OutputState }

Specifies the audit configuration for a service. The configuration determines which permission types are logged, and what identities, if any, are exempted from logging. An AuditConfig must have one or more AuditLogConfigs. If there are AuditConfigs for both `allServices` and a specific service, the union of the two AuditConfigs is used for that service: the log_types specified in each AuditConfig are enabled, and the exempted_members in each AuditLogConfig are exempted. Example Policy with multiple AuditConfigs: { "audit_configs": [ { "service": "allServices", "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] }, { "log_type": "DATA_WRITE" }, { "log_type": "ADMIN_READ" } ] }, { "service": "sampleservice.googleapis.com", "audit_log_configs": [ { "log_type": "DATA_READ" }, { "log_type": "DATA_WRITE", "exempted_members": [ "user:aliya@example.com" ] } ] } ] } For sampleservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ logging. It also exempts jose@example.com from DATA_READ logging, and aliya@example.com from DATA_WRITE logging.

func (AuditConfigOutput) AuditLogConfigs 

func (o AuditConfigOutput) AuditLogConfigs() AuditLogConfigArrayOutput

The configuration for logging of each type of permission.

func (AuditConfigOutput) ElementType 

func (AuditConfigOutput) ElementType() reflect.Type

func (AuditConfigOutput) ExemptedMembers 

func (o AuditConfigOutput) ExemptedMembers() pulumi.StringArrayOutput

func (AuditConfigOutput) Service 

func (o AuditConfigOutput) Service() pulumi.StringPtrOutput

Specifies a service that will be enabled for audit logging. For example, `storage.googleapis.com`, `cloudsql.googleapis.com`. `allServices` is a special value that covers all services.

func (AuditConfigOutput) ToAuditConfigOutput 

func (o AuditConfigOutput) ToAuditConfigOutput() AuditConfigOutput

func (AuditConfigOutput) ToAuditConfigOutputWithContext 

func (o AuditConfigOutput) ToAuditConfigOutputWithContext(ctx context.Context) AuditConfigOutput

type AuditConfigResponse 

type AuditConfigResponse struct {
	// The configuration for logging of each type of permission.
	AuditLogConfigs []AuditLogConfigResponse `pulumi:"auditLogConfigs"`
	ExemptedMembers []string                 `pulumi:"exemptedMembers"`
	// Specifies a service that will be enabled for audit logging. For example, `storage.googleapis.com`, `cloudsql.googleapis.com`. `allServices` is a special value that covers all services.
	Service string `pulumi:"service"`
}

Specifies the audit configuration for a service. The configuration determines which permission types are logged, and what identities, if any, are exempted from logging. An AuditConfig must have one or more AuditLogConfigs. If there are AuditConfigs for both `allServices` and a specific service, the union of the two AuditConfigs is used for that service: the log_types specified in each AuditConfig are enabled, and the exempted_members in each AuditLogConfig are exempted. Example Policy with multiple AuditConfigs: { "audit_configs": [ { "service": "allServices", "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] }, { "log_type": "DATA_WRITE" }, { "log_type": "ADMIN_READ" } ] }, { "service": "sampleservice.googleapis.com", "audit_log_configs": [ { "log_type": "DATA_READ" }, { "log_type": "DATA_WRITE", "exempted_members": [ "user:aliya@example.com" ] } ] } ] } For sampleservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ logging. It also exempts jose@example.com from DATA_READ logging, and aliya@example.com from DATA_WRITE logging.

type AuditConfigResponseArgs 

type AuditConfigResponseArgs struct {
	// The configuration for logging of each type of permission.
	AuditLogConfigs AuditLogConfigResponseArrayInput `pulumi:"auditLogConfigs"`
	ExemptedMembers pulumi.StringArrayInput          `pulumi:"exemptedMembers"`
	// Specifies a service that will be enabled for audit logging. For example, `storage.googleapis.com`, `cloudsql.googleapis.com`. `allServices` is a special value that covers all services.
	Service pulumi.StringInput `pulumi:"service"`
}

Specifies the audit configuration for a service. The configuration determines which permission types are logged, and what identities, if any, are exempted from logging. An AuditConfig must have one or more AuditLogConfigs. If there are AuditConfigs for both `allServices` and a specific service, the union of the two AuditConfigs is used for that service: the log_types specified in each AuditConfig are enabled, and the exempted_members in each AuditLogConfig are exempted. Example Policy with multiple AuditConfigs: { "audit_configs": [ { "service": "allServices", "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] }, { "log_type": "DATA_WRITE" }, { "log_type": "ADMIN_READ" } ] }, { "service": "sampleservice.googleapis.com", "audit_log_configs": [ { "log_type": "DATA_READ" }, { "log_type": "DATA_WRITE", "exempted_members": [ "user:aliya@example.com" ] } ] } ] } For sampleservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ logging. It also exempts jose@example.com from DATA_READ logging, and aliya@example.com from DATA_WRITE logging.

func (AuditConfigResponseArgs) ElementType 

func (AuditConfigResponseArgs) ElementType() reflect.Type

func (AuditConfigResponseArgs) ToAuditConfigResponseOutput 

func (i AuditConfigResponseArgs) ToAuditConfigResponseOutput() AuditConfigResponseOutput

func (AuditConfigResponseArgs) ToAuditConfigResponseOutputWithContext 

func (i AuditConfigResponseArgs) ToAuditConfigResponseOutputWithContext(ctx context.Context) AuditConfigResponseOutput

type AuditConfigResponseArray 

type AuditConfigResponseArray []AuditConfigResponseInput

func (AuditConfigResponseArray) ElementType 

func (AuditConfigResponseArray) ElementType() reflect.Type

func (AuditConfigResponseArray) ToAuditConfigResponseArrayOutput 

func (i AuditConfigResponseArray) ToAuditConfigResponseArrayOutput() AuditConfigResponseArrayOutput

func (AuditConfigResponseArray) ToAuditConfigResponseArrayOutputWithContext 

func (i AuditConfigResponseArray) ToAuditConfigResponseArrayOutputWithContext(ctx context.Context) AuditConfigResponseArrayOutput

type AuditConfigResponseArrayInput 

type AuditConfigResponseArrayInput interface {
	pulumi.Input

	ToAuditConfigResponseArrayOutput() AuditConfigResponseArrayOutput
	ToAuditConfigResponseArrayOutputWithContext(context.Context) AuditConfigResponseArrayOutput
}

AuditConfigResponseArrayInput is an input type that accepts AuditConfigResponseArray and AuditConfigResponseArrayOutput values. You can construct a concrete instance of `AuditConfigResponseArrayInput` via: 

AuditConfigResponseArray{ AuditConfigResponseArgs{...} }

type AuditConfigResponseArrayOutput 

type AuditConfigResponseArrayOutput struct{ *pulumi.OutputState }

func (AuditConfigResponseArrayOutput) ElementType 

func (AuditConfigResponseArrayOutput) ElementType() reflect.Type

func (AuditConfigResponseArrayOutput) Index 

func (o AuditConfigResponseArrayOutput) Index(i pulumi.IntInput) AuditConfigResponseOutput

func (AuditConfigResponseArrayOutput) ToAuditConfigResponseArrayOutput 

func (o AuditConfigResponseArrayOutput) ToAuditConfigResponseArrayOutput() AuditConfigResponseArrayOutput

func (AuditConfigResponseArrayOutput) ToAuditConfigResponseArrayOutputWithContext 

func (o AuditConfigResponseArrayOutput) ToAuditConfigResponseArrayOutputWithContext(ctx context.Context) AuditConfigResponseArrayOutput

type AuditConfigResponseInput 

type AuditConfigResponseInput interface {
	pulumi.Input

	ToAuditConfigResponseOutput() AuditConfigResponseOutput
	ToAuditConfigResponseOutputWithContext(context.Context) AuditConfigResponseOutput
}

AuditConfigResponseInput is an input type that accepts AuditConfigResponseArgs and AuditConfigResponseOutput values. You can construct a concrete instance of `AuditConfigResponseInput` via: 

AuditConfigResponseArgs{...}

type AuditConfigResponseOutput 

type AuditConfigResponseOutput struct{ *pulumi.OutputState }

Specifies the audit configuration for a service. The configuration determines which permission types are logged, and what identities, if any, are exempted from logging. An AuditConfig must have one or more AuditLogConfigs. If there are AuditConfigs for both `allServices` and a specific service, the union of the two AuditConfigs is used for that service: the log_types specified in each AuditConfig are enabled, and the exempted_members in each AuditLogConfig are exempted. Example Policy with multiple AuditConfigs: { "audit_configs": [ { "service": "allServices", "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] }, { "log_type": "DATA_WRITE" }, { "log_type": "ADMIN_READ" } ] }, { "service": "sampleservice.googleapis.com", "audit_log_configs": [ { "log_type": "DATA_READ" }, { "log_type": "DATA_WRITE", "exempted_members": [ "user:aliya@example.com" ] } ] } ] } For sampleservice, this policy enables DATA_READ, DATA_WRITE and ADMIN_READ logging. It also exempts jose@example.com from DATA_READ logging, and aliya@example.com from DATA_WRITE logging.

func (AuditConfigResponseOutput) AuditLogConfigs 

func (o AuditConfigResponseOutput) AuditLogConfigs() AuditLogConfigResponseArrayOutput

The configuration for logging of each type of permission.

func (AuditConfigResponseOutput) ElementType 

func (AuditConfigResponseOutput) ElementType() reflect.Type

func (AuditConfigResponseOutput) ExemptedMembers 

func (o AuditConfigResponseOutput) ExemptedMembers() pulumi.StringArrayOutput

func (AuditConfigResponseOutput) Service 

func (o AuditConfigResponseOutput) Service() pulumi.StringOutput

Specifies a service that will be enabled for audit logging. For example, `storage.googleapis.com`, `cloudsql.googleapis.com`. `allServices` is a special value that covers all services.

func (AuditConfigResponseOutput) ToAuditConfigResponseOutput 

func (o AuditConfigResponseOutput) ToAuditConfigResponseOutput() AuditConfigResponseOutput

func (AuditConfigResponseOutput) ToAuditConfigResponseOutputWithContext 

func (o AuditConfigResponseOutput) ToAuditConfigResponseOutputWithContext(ctx context.Context) AuditConfigResponseOutput

type AuditLogConfig 

type AuditLogConfig struct {
	// Specifies the identities that do not cause logging for this type of permission. Follows the same format of Binding.members.
	ExemptedMembers       []string `pulumi:"exemptedMembers"`
	IgnoreChildExemptions *bool    `pulumi:"ignoreChildExemptions"`
	// The log type that this config enables.
	LogType *string `pulumi:"logType"`
}

Provides the configuration for logging a type of permissions. Example: { "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] }, { "log_type": "DATA_WRITE" } ] } This enables 'DATA_READ' and 'DATA_WRITE' logging, while exempting jose@example.com from DATA_READ logging.

type AuditLogConfigArgs 

type AuditLogConfigArgs struct {
	// Specifies the identities that do not cause logging for this type of permission. Follows the same format of Binding.members.
	ExemptedMembers       pulumi.StringArrayInput `pulumi:"exemptedMembers"`
	IgnoreChildExemptions pulumi.BoolPtrInput     `pulumi:"ignoreChildExemptions"`
	// The log type that this config enables.
	LogType pulumi.StringPtrInput `pulumi:"logType"`
}

Provides the configuration for logging a type of permissions. Example: { "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] }, { "log_type": "DATA_WRITE" } ] } This enables 'DATA_READ' and 'DATA_WRITE' logging, while exempting jose@example.com from DATA_READ logging.

func (AuditLogConfigArgs) ElementType 

func (AuditLogConfigArgs) ElementType() reflect.Type

func (AuditLogConfigArgs) ToAuditLogConfigOutput 

func (i AuditLogConfigArgs) ToAuditLogConfigOutput() AuditLogConfigOutput

func (AuditLogConfigArgs) ToAuditLogConfigOutputWithContext 

func (i AuditLogConfigArgs) ToAuditLogConfigOutputWithContext(ctx context.Context) AuditLogConfigOutput

type AuditLogConfigArray 

type AuditLogConfigArray []AuditLogConfigInput

func (AuditLogConfigArray) ElementType 

func (AuditLogConfigArray) ElementType() reflect.Type

func (AuditLogConfigArray) ToAuditLogConfigArrayOutput 

func (i AuditLogConfigArray) ToAuditLogConfigArrayOutput() AuditLogConfigArrayOutput

func (AuditLogConfigArray) ToAuditLogConfigArrayOutputWithContext 

func (i AuditLogConfigArray) ToAuditLogConfigArrayOutputWithContext(ctx context.Context) AuditLogConfigArrayOutput

type AuditLogConfigArrayInput 

type AuditLogConfigArrayInput interface {
	pulumi.Input

	ToAuditLogConfigArrayOutput() AuditLogConfigArrayOutput
	ToAuditLogConfigArrayOutputWithContext(context.Context) AuditLogConfigArrayOutput
}

AuditLogConfigArrayInput is an input type that accepts AuditLogConfigArray and AuditLogConfigArrayOutput values. You can construct a concrete instance of `AuditLogConfigArrayInput` via: 

AuditLogConfigArray{ AuditLogConfigArgs{...} }

type AuditLogConfigArrayOutput 

type AuditLogConfigArrayOutput struct{ *pulumi.OutputState }

func (AuditLogConfigArrayOutput) ElementType 

func (AuditLogConfigArrayOutput) ElementType() reflect.Type

func (AuditLogConfigArrayOutput) Index 

func (o AuditLogConfigArrayOutput) Index(i pulumi.IntInput) AuditLogConfigOutput

func (AuditLogConfigArrayOutput) ToAuditLogConfigArrayOutput 

func (o AuditLogConfigArrayOutput) ToAuditLogConfigArrayOutput() AuditLogConfigArrayOutput

func (AuditLogConfigArrayOutput) ToAuditLogConfigArrayOutputWithContext 

func (o AuditLogConfigArrayOutput) ToAuditLogConfigArrayOutputWithContext(ctx context.Context) AuditLogConfigArrayOutput

type AuditLogConfigInput 

type AuditLogConfigInput interface {
	pulumi.Input

	ToAuditLogConfigOutput() AuditLogConfigOutput
	ToAuditLogConfigOutputWithContext(context.Context) AuditLogConfigOutput
}

AuditLogConfigInput is an input type that accepts AuditLogConfigArgs and AuditLogConfigOutput values. You can construct a concrete instance of `AuditLogConfigInput` via: 

AuditLogConfigArgs{...}

type AuditLogConfigOutput 

type AuditLogConfigOutput struct{ *pulumi.OutputState }

Provides the configuration for logging a type of permissions. Example: { "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] }, { "log_type": "DATA_WRITE" } ] } This enables 'DATA_READ' and 'DATA_WRITE' logging, while exempting jose@example.com from DATA_READ logging.

func (AuditLogConfigOutput) ElementType 

func (AuditLogConfigOutput) ElementType() reflect.Type

func (AuditLogConfigOutput) ExemptedMembers 

func (o AuditLogConfigOutput) ExemptedMembers() pulumi.StringArrayOutput

Specifies the identities that do not cause logging for this type of permission. Follows the same format of Binding.members.

func (AuditLogConfigOutput) IgnoreChildExemptions 

func (o AuditLogConfigOutput) IgnoreChildExemptions() pulumi.BoolPtrOutput

func (AuditLogConfigOutput) LogType 

func (o AuditLogConfigOutput) LogType() pulumi.StringPtrOutput

The log type that this config enables.

func (AuditLogConfigOutput) ToAuditLogConfigOutput 

func (o AuditLogConfigOutput) ToAuditLogConfigOutput() AuditLogConfigOutput

func (AuditLogConfigOutput) ToAuditLogConfigOutputWithContext 

func (o AuditLogConfigOutput) ToAuditLogConfigOutputWithContext(ctx context.Context) AuditLogConfigOutput

type AuditLogConfigResponse 

type AuditLogConfigResponse struct {
	// Specifies the identities that do not cause logging for this type of permission. Follows the same format of Binding.members.
	ExemptedMembers       []string `pulumi:"exemptedMembers"`
	IgnoreChildExemptions bool     `pulumi:"ignoreChildExemptions"`
	// The log type that this config enables.
	LogType string `pulumi:"logType"`
}

Provides the configuration for logging a type of permissions. Example: { "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] }, { "log_type": "DATA_WRITE" } ] } This enables 'DATA_READ' and 'DATA_WRITE' logging, while exempting jose@example.com from DATA_READ logging.

type AuditLogConfigResponseArgs 

type AuditLogConfigResponseArgs struct {
	// Specifies the identities that do not cause logging for this type of permission. Follows the same format of Binding.members.
	ExemptedMembers       pulumi.StringArrayInput `pulumi:"exemptedMembers"`
	IgnoreChildExemptions pulumi.BoolInput        `pulumi:"ignoreChildExemptions"`
	// The log type that this config enables.
	LogType pulumi.StringInput `pulumi:"logType"`
}

Provides the configuration for logging a type of permissions. Example: { "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] }, { "log_type": "DATA_WRITE" } ] } This enables 'DATA_READ' and 'DATA_WRITE' logging, while exempting jose@example.com from DATA_READ logging.

func (AuditLogConfigResponseArgs) ElementType 

func (AuditLogConfigResponseArgs) ElementType() reflect.Type

func (AuditLogConfigResponseArgs) ToAuditLogConfigResponseOutput 

func (i AuditLogConfigResponseArgs) ToAuditLogConfigResponseOutput() AuditLogConfigResponseOutput

func (AuditLogConfigResponseArgs) ToAuditLogConfigResponseOutputWithContext 

func (i AuditLogConfigResponseArgs) ToAuditLogConfigResponseOutputWithContext(ctx context.Context) AuditLogConfigResponseOutput

type AuditLogConfigResponseArray 

type AuditLogConfigResponseArray []AuditLogConfigResponseInput

func (AuditLogConfigResponseArray) ElementType 

func (AuditLogConfigResponseArray) ElementType() reflect.Type

func (AuditLogConfigResponseArray) ToAuditLogConfigResponseArrayOutput 

func (i AuditLogConfigResponseArray) ToAuditLogConfigResponseArrayOutput() AuditLogConfigResponseArrayOutput

func (AuditLogConfigResponseArray) ToAuditLogConfigResponseArrayOutputWithContext 

func (i AuditLogConfigResponseArray) ToAuditLogConfigResponseArrayOutputWithContext(ctx context.Context) AuditLogConfigResponseArrayOutput

type AuditLogConfigResponseArrayInput 

type AuditLogConfigResponseArrayInput interface {
	pulumi.Input

	ToAuditLogConfigResponseArrayOutput() AuditLogConfigResponseArrayOutput
	ToAuditLogConfigResponseArrayOutputWithContext(context.Context) AuditLogConfigResponseArrayOutput
}

AuditLogConfigResponseArrayInput is an input type that accepts AuditLogConfigResponseArray and AuditLogConfigResponseArrayOutput values. You can construct a concrete instance of `AuditLogConfigResponseArrayInput` via: 

AuditLogConfigResponseArray{ AuditLogConfigResponseArgs{...} }

type AuditLogConfigResponseArrayOutput 

type AuditLogConfigResponseArrayOutput struct{ *pulumi.OutputState }

func (AuditLogConfigResponseArrayOutput) ElementType 

func (AuditLogConfigResponseArrayOutput) ElementType() reflect.Type

func (AuditLogConfigResponseArrayOutput) Index 

func (o AuditLogConfigResponseArrayOutput) Index(i pulumi.IntInput) AuditLogConfigResponseOutput

func (AuditLogConfigResponseArrayOutput) ToAuditLogConfigResponseArrayOutput 

func (o AuditLogConfigResponseArrayOutput) ToAuditLogConfigResponseArrayOutput() AuditLogConfigResponseArrayOutput

func (AuditLogConfigResponseArrayOutput) ToAuditLogConfigResponseArrayOutputWithContext 

func (o AuditLogConfigResponseArrayOutput) ToAuditLogConfigResponseArrayOutputWithContext(ctx context.Context) AuditLogConfigResponseArrayOutput

type AuditLogConfigResponseInput 

type AuditLogConfigResponseInput interface {
	pulumi.Input

	ToAuditLogConfigResponseOutput() AuditLogConfigResponseOutput
	ToAuditLogConfigResponseOutputWithContext(context.Context) AuditLogConfigResponseOutput
}

AuditLogConfigResponseInput is an input type that accepts AuditLogConfigResponseArgs and AuditLogConfigResponseOutput values. You can construct a concrete instance of `AuditLogConfigResponseInput` via: 

AuditLogConfigResponseArgs{...}

type AuditLogConfigResponseOutput 

type AuditLogConfigResponseOutput struct{ *pulumi.OutputState }

Provides the configuration for logging a type of permissions. Example: { "audit_log_configs": [ { "log_type": "DATA_READ", "exempted_members": [ "user:jose@example.com" ] }, { "log_type": "DATA_WRITE" } ] } This enables 'DATA_READ' and 'DATA_WRITE' logging, while exempting jose@example.com from DATA_READ logging.

func (AuditLogConfigResponseOutput) ElementType 

func (AuditLogConfigResponseOutput) ElementType() reflect.Type

func (AuditLogConfigResponseOutput) ExemptedMembers 

func (o AuditLogConfigResponseOutput) ExemptedMembers() pulumi.StringArrayOutput

Specifies the identities that do not cause logging for this type of permission. Follows the same format of Binding.members.

func (AuditLogConfigResponseOutput) IgnoreChildExemptions 

func (o AuditLogConfigResponseOutput) IgnoreChildExemptions() pulumi.BoolOutput

func (AuditLogConfigResponseOutput) LogType 

func (o AuditLogConfigResponseOutput) LogType() pulumi.StringOutput

The log type that this config enables.

func (AuditLogConfigResponseOutput) ToAuditLogConfigResponseOutput 

func (o AuditLogConfigResponseOutput) ToAuditLogConfigResponseOutput() AuditLogConfigResponseOutput

func (AuditLogConfigResponseOutput) ToAuditLogConfigResponseOutputWithContext 

func (o AuditLogConfigResponseOutput) ToAuditLogConfigResponseOutputWithContext(ctx context.Context) AuditLogConfigResponseOutput

type AuthorizationLoggingOptions 

type AuthorizationLoggingOptions struct {
	// The type of the permission that was checked.
	PermissionType *string `pulumi:"permissionType"`
}

Authorization-related information used by Cloud Audit Logging.

type AuthorizationLoggingOptionsArgs 

type AuthorizationLoggingOptionsArgs struct {
	// The type of the permission that was checked.
	PermissionType pulumi.StringPtrInput `pulumi:"permissionType"`
}

Authorization-related information used by Cloud Audit Logging.

func (AuthorizationLoggingOptionsArgs) ElementType 

func (AuthorizationLoggingOptionsArgs) ElementType() reflect.Type

func (AuthorizationLoggingOptionsArgs) ToAuthorizationLoggingOptionsOutput 

func (i AuthorizationLoggingOptionsArgs) ToAuthorizationLoggingOptionsOutput() AuthorizationLoggingOptionsOutput

func (AuthorizationLoggingOptionsArgs) ToAuthorizationLoggingOptionsOutputWithContext 

func (i AuthorizationLoggingOptionsArgs) ToAuthorizationLoggingOptionsOutputWithContext(ctx context.Context) AuthorizationLoggingOptionsOutput

func (AuthorizationLoggingOptionsArgs) ToAuthorizationLoggingOptionsPtrOutput 

func (i AuthorizationLoggingOptionsArgs) ToAuthorizationLoggingOptionsPtrOutput() AuthorizationLoggingOptionsPtrOutput

func (AuthorizationLoggingOptionsArgs) ToAuthorizationLoggingOptionsPtrOutputWithContext 

func (i AuthorizationLoggingOptionsArgs) ToAuthorizationLoggingOptionsPtrOutputWithContext(ctx context.Context) AuthorizationLoggingOptionsPtrOutput

type AuthorizationLoggingOptionsInput 

type AuthorizationLoggingOptionsInput interface {
	pulumi.Input

	ToAuthorizationLoggingOptionsOutput() AuthorizationLoggingOptionsOutput
	ToAuthorizationLoggingOptionsOutputWithContext(context.Context) AuthorizationLoggingOptionsOutput
}

AuthorizationLoggingOptionsInput is an input type that accepts AuthorizationLoggingOptionsArgs and AuthorizationLoggingOptionsOutput values. You can construct a concrete instance of `AuthorizationLoggingOptionsInput` via: 

AuthorizationLoggingOptionsArgs{...}

type AuthorizationLoggingOptionsOutput 

type AuthorizationLoggingOptionsOutput struct{ *pulumi.OutputState }

Authorization-related information used by Cloud Audit Logging.

func (AuthorizationLoggingOptionsOutput) ElementType 

func (AuthorizationLoggingOptionsOutput) ElementType() reflect.Type

func (AuthorizationLoggingOptionsOutput) PermissionType 

func (o AuthorizationLoggingOptionsOutput) PermissionType() pulumi.StringPtrOutput

The type of the permission that was checked.

func (AuthorizationLoggingOptionsOutput) ToAuthorizationLoggingOptionsOutput 

func (o AuthorizationLoggingOptionsOutput) ToAuthorizationLoggingOptionsOutput() AuthorizationLoggingOptionsOutput

func (AuthorizationLoggingOptionsOutput) ToAuthorizationLoggingOptionsOutputWithContext 

func (o AuthorizationLoggingOptionsOutput) ToAuthorizationLoggingOptionsOutputWithContext(ctx context.Context) AuthorizationLoggingOptionsOutput

func (AuthorizationLoggingOptionsOutput) ToAuthorizationLoggingOptionsPtrOutput 

func (o AuthorizationLoggingOptionsOutput) ToAuthorizationLoggingOptionsPtrOutput() AuthorizationLoggingOptionsPtrOutput

func (AuthorizationLoggingOptionsOutput) ToAuthorizationLoggingOptionsPtrOutputWithContext 

func (o AuthorizationLoggingOptionsOutput) ToAuthorizationLoggingOptionsPtrOutputWithContext(ctx context.Context) AuthorizationLoggingOptionsPtrOutput

type AuthorizationLoggingOptionsPtrInput 

type AuthorizationLoggingOptionsPtrInput interface {
	pulumi.Input

	ToAuthorizationLoggingOptionsPtrOutput() AuthorizationLoggingOptionsPtrOutput
	ToAuthorizationLoggingOptionsPtrOutputWithContext(context.Context) AuthorizationLoggingOptionsPtrOutput
}

AuthorizationLoggingOptionsPtrInput is an input type that accepts AuthorizationLoggingOptionsArgs, AuthorizationLoggingOptionsPtr and AuthorizationLoggingOptionsPtrOutput values. You can construct a concrete instance of `AuthorizationLoggingOptionsPtrInput` via: 

        AuthorizationLoggingOptionsArgs{...}

or:

        nil

func AuthorizationLoggingOptionsPtr 

func AuthorizationLoggingOptionsPtr(v *AuthorizationLoggingOptionsArgs) AuthorizationLoggingOptionsPtrInput

type AuthorizationLoggingOptionsPtrOutput 

type AuthorizationLoggingOptionsPtrOutput struct{ *pulumi.OutputState }

func (AuthorizationLoggingOptionsPtrOutput) Elem 

func (o AuthorizationLoggingOptionsPtrOutput) Elem() AuthorizationLoggingOptionsOutput

func (AuthorizationLoggingOptionsPtrOutput) ElementType 

func (AuthorizationLoggingOptionsPtrOutput) ElementType() reflect.Type

func (AuthorizationLoggingOptionsPtrOutput) PermissionType 

func (o AuthorizationLoggingOptionsPtrOutput) PermissionType() pulumi.StringPtrOutput

The type of the permission that was checked.

func (AuthorizationLoggingOptionsPtrOutput) ToAuthorizationLoggingOptionsPtrOutput 

func (o AuthorizationLoggingOptionsPtrOutput) ToAuthorizationLoggingOptionsPtrOutput() AuthorizationLoggingOptionsPtrOutput

func (AuthorizationLoggingOptionsPtrOutput) ToAuthorizationLoggingOptionsPtrOutputWithContext 

func (o AuthorizationLoggingOptionsPtrOutput) ToAuthorizationLoggingOptionsPtrOutputWithContext(ctx context.Context) AuthorizationLoggingOptionsPtrOutput

type AuthorizationLoggingOptionsResponse 

type AuthorizationLoggingOptionsResponse struct {
	// The type of the permission that was checked.
	PermissionType string `pulumi:"permissionType"`
}

Authorization-related information used by Cloud Audit Logging.

type AuthorizationLoggingOptionsResponseArgs 

type AuthorizationLoggingOptionsResponseArgs struct {
	// The type of the permission that was checked.
	PermissionType pulumi.StringInput `pulumi:"permissionType"`
}

Authorization-related information used by Cloud Audit Logging.

func (AuthorizationLoggingOptionsResponseArgs) ElementType 

func (AuthorizationLoggingOptionsResponseArgs) ElementType() reflect.Type

func (AuthorizationLoggingOptionsResponseArgs) ToAuthorizationLoggingOptionsResponseOutput 

func (i AuthorizationLoggingOptionsResponseArgs) ToAuthorizationLoggingOptionsResponseOutput() AuthorizationLoggingOptionsResponseOutput

func (AuthorizationLoggingOptionsResponseArgs) ToAuthorizationLoggingOptionsResponseOutputWithContext 

func (i AuthorizationLoggingOptionsResponseArgs) ToAuthorizationLoggingOptionsResponseOutputWithContext(ctx context.Context) AuthorizationLoggingOptionsResponseOutput

type AuthorizationLoggingOptionsResponseInput 

type AuthorizationLoggingOptionsResponseInput interface {
	pulumi.Input

	ToAuthorizationLoggingOptionsResponseOutput() AuthorizationLoggingOptionsResponseOutput
	ToAuthorizationLoggingOptionsResponseOutputWithContext(context.Context) AuthorizationLoggingOptionsResponseOutput
}

AuthorizationLoggingOptionsResponseInput is an input type that accepts AuthorizationLoggingOptionsResponseArgs and AuthorizationLoggingOptionsResponseOutput values. You can construct a concrete instance of `AuthorizationLoggingOptionsResponseInput` via: 

AuthorizationLoggingOptionsResponseArgs{...}

type AuthorizationLoggingOptionsResponseOutput 

type AuthorizationLoggingOptionsResponseOutput struct{ *pulumi.OutputState }

Authorization-related information used by Cloud Audit Logging.

func (AuthorizationLoggingOptionsResponseOutput) ElementType 

func (AuthorizationLoggingOptionsResponseOutput) ElementType() reflect.Type

func (AuthorizationLoggingOptionsResponseOutput) PermissionType 

func (o AuthorizationLoggingOptionsResponseOutput) PermissionType() pulumi.StringOutput

The type of the permission that was checked.

func (AuthorizationLoggingOptionsResponseOutput) ToAuthorizationLoggingOptionsResponseOutput 

func (o AuthorizationLoggingOptionsResponseOutput) ToAuthorizationLoggingOptionsResponseOutput() AuthorizationLoggingOptionsResponseOutput

func (AuthorizationLoggingOptionsResponseOutput) ToAuthorizationLoggingOptionsResponseOutputWithContext 

func (o AuthorizationLoggingOptionsResponseOutput) ToAuthorizationLoggingOptionsResponseOutputWithContext(ctx context.Context) AuthorizationLoggingOptionsResponseOutput

type Binding 

type Binding struct {
	BindingId *string `pulumi:"bindingId"`
	// The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the members in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
	Condition *Expr `pulumi:"condition"`
	// Specifies the identities requesting access for a Cloud Platform resource. `members` can have the following values: * `allUsers`: A special identifier that represents anyone who is on the internet; with or without a Google account. * `allAuthenticatedUsers`: A special identifier that represents anyone who is authenticated with a Google account or a service account. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid}`: An email address that represents a service account. For example, `my-other-app@appspot.gserviceaccount.com`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, `alice@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, `admins@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid}` and the recovered group retains the role in the binding. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`.
	Members []string `pulumi:"members"`
	// Role that is assigned to `members`. For example, `roles/viewer`, `roles/editor`, or `roles/owner`.
	Role *string `pulumi:"role"`
}

Associates `members` with a `role`.

type BindingArgs 

type BindingArgs struct {
	BindingId pulumi.StringPtrInput `pulumi:"bindingId"`
	// The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the members in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
	Condition ExprPtrInput `pulumi:"condition"`
	// Specifies the identities requesting access for a Cloud Platform resource. `members` can have the following values: * `allUsers`: A special identifier that represents anyone who is on the internet; with or without a Google account. * `allAuthenticatedUsers`: A special identifier that represents anyone who is authenticated with a Google account or a service account. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid}`: An email address that represents a service account. For example, `my-other-app@appspot.gserviceaccount.com`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, `alice@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, `admins@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid}` and the recovered group retains the role in the binding. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`.
	Members pulumi.StringArrayInput `pulumi:"members"`
	// Role that is assigned to `members`. For example, `roles/viewer`, `roles/editor`, or `roles/owner`.
	Role pulumi.StringPtrInput `pulumi:"role"`
}

Associates `members` with a `role`.

func (BindingArgs) ElementType 

func (BindingArgs) ElementType() reflect.Type

func (BindingArgs) ToBindingOutput 

func (i BindingArgs) ToBindingOutput() BindingOutput

func (BindingArgs) ToBindingOutputWithContext 

func (i BindingArgs) ToBindingOutputWithContext(ctx context.Context) BindingOutput

type BindingArray 

type BindingArray []BindingInput

func (BindingArray) ElementType 

func (BindingArray) ElementType() reflect.Type

func (BindingArray) ToBindingArrayOutput 

func (i BindingArray) ToBindingArrayOutput() BindingArrayOutput

func (BindingArray) ToBindingArrayOutputWithContext 

func (i BindingArray) ToBindingArrayOutputWithContext(ctx context.Context) BindingArrayOutput

type BindingArrayInput 

type BindingArrayInput interface {
	pulumi.Input

	ToBindingArrayOutput() BindingArrayOutput
	ToBindingArrayOutputWithContext(context.Context) BindingArrayOutput
}

BindingArrayInput is an input type that accepts BindingArray and BindingArrayOutput values. You can construct a concrete instance of `BindingArrayInput` via: 

BindingArray{ BindingArgs{...} }

type BindingArrayOutput 

type BindingArrayOutput struct{ *pulumi.OutputState }

func (BindingArrayOutput) ElementType 

func (BindingArrayOutput) ElementType() reflect.Type

func (BindingArrayOutput) Index 

func (o BindingArrayOutput) Index(i pulumi.IntInput) BindingOutput

func (BindingArrayOutput) ToBindingArrayOutput 

func (o BindingArrayOutput) ToBindingArrayOutput() BindingArrayOutput

func (BindingArrayOutput) ToBindingArrayOutputWithContext 

func (o BindingArrayOutput) ToBindingArrayOutputWithContext(ctx context.Context) BindingArrayOutput

type BindingInput 

type BindingInput interface {
	pulumi.Input

	ToBindingOutput() BindingOutput
	ToBindingOutputWithContext(context.Context) BindingOutput
}

BindingInput is an input type that accepts BindingArgs and BindingOutput values. You can construct a concrete instance of `BindingInput` via: 

BindingArgs{...}

type BindingOutput 

type BindingOutput struct{ *pulumi.OutputState }

Associates `members` with a `role`.

func (BindingOutput) BindingId 

func (o BindingOutput) BindingId() pulumi.StringPtrOutput

func (BindingOutput) Condition 

func (o BindingOutput) Condition() ExprPtrOutput

The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the members in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).

func (BindingOutput) ElementType 

func (BindingOutput) ElementType() reflect.Type

func (BindingOutput) Members 

func (o BindingOutput) Members() pulumi.StringArrayOutput

Specifies the identities requesting access for a Cloud Platform resource. `members` can have the following values: * `allUsers`: A special identifier that represents anyone who is on the internet; with or without a Google account. * `allAuthenticatedUsers`: A special identifier that represents anyone who is authenticated with a Google account or a service account. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid}`: An email address that represents a service account. For example, `my-other-app@appspot.gserviceaccount.com`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, `alice@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, `admins@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid}` and the recovered group retains the role in the binding. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`.

func (BindingOutput) Role 

func (o BindingOutput) Role() pulumi.StringPtrOutput

Role that is assigned to `members`. For example, `roles/viewer`, `roles/editor`, or `roles/owner`.

func (BindingOutput) ToBindingOutput 

func (o BindingOutput) ToBindingOutput() BindingOutput

func (BindingOutput) ToBindingOutputWithContext 

func (o BindingOutput) ToBindingOutputWithContext(ctx context.Context) BindingOutput

type BindingResponse 

type BindingResponse struct {
	BindingId string `pulumi:"bindingId"`
	// The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the members in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
	Condition ExprResponse `pulumi:"condition"`
	// Specifies the identities requesting access for a Cloud Platform resource. `members` can have the following values: * `allUsers`: A special identifier that represents anyone who is on the internet; with or without a Google account. * `allAuthenticatedUsers`: A special identifier that represents anyone who is authenticated with a Google account or a service account. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid}`: An email address that represents a service account. For example, `my-other-app@appspot.gserviceaccount.com`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, `alice@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, `admins@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid}` and the recovered group retains the role in the binding. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`.
	Members []string `pulumi:"members"`
	// Role that is assigned to `members`. For example, `roles/viewer`, `roles/editor`, or `roles/owner`.
	Role string `pulumi:"role"`
}

Associates `members` with a `role`.

type BindingResponseArgs 

type BindingResponseArgs struct {
	BindingId pulumi.StringInput `pulumi:"bindingId"`
	// The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the members in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
	Condition ExprResponseInput `pulumi:"condition"`
	// Specifies the identities requesting access for a Cloud Platform resource. `members` can have the following values: * `allUsers`: A special identifier that represents anyone who is on the internet; with or without a Google account. * `allAuthenticatedUsers`: A special identifier that represents anyone who is authenticated with a Google account or a service account. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid}`: An email address that represents a service account. For example, `my-other-app@appspot.gserviceaccount.com`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, `alice@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, `admins@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid}` and the recovered group retains the role in the binding. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`.
	Members pulumi.StringArrayInput `pulumi:"members"`
	// Role that is assigned to `members`. For example, `roles/viewer`, `roles/editor`, or `roles/owner`.
	Role pulumi.StringInput `pulumi:"role"`
}

Associates `members` with a `role`.

func (BindingResponseArgs) ElementType 

func (BindingResponseArgs) ElementType() reflect.Type

func (BindingResponseArgs) ToBindingResponseOutput 

func (i BindingResponseArgs) ToBindingResponseOutput() BindingResponseOutput

func (BindingResponseArgs) ToBindingResponseOutputWithContext 

func (i BindingResponseArgs) ToBindingResponseOutputWithContext(ctx context.Context) BindingResponseOutput

type BindingResponseArray 

type BindingResponseArray []BindingResponseInput

func (BindingResponseArray) ElementType 

func (BindingResponseArray) ElementType() reflect.Type

func (BindingResponseArray) ToBindingResponseArrayOutput 

func (i BindingResponseArray) ToBindingResponseArrayOutput() BindingResponseArrayOutput

func (BindingResponseArray) ToBindingResponseArrayOutputWithContext 

func (i BindingResponseArray) ToBindingResponseArrayOutputWithContext(ctx context.Context) BindingResponseArrayOutput

type BindingResponseArrayInput 

type BindingResponseArrayInput interface {
	pulumi.Input

	ToBindingResponseArrayOutput() BindingResponseArrayOutput
	ToBindingResponseArrayOutputWithContext(context.Context) BindingResponseArrayOutput
}

BindingResponseArrayInput is an input type that accepts BindingResponseArray and BindingResponseArrayOutput values. You can construct a concrete instance of `BindingResponseArrayInput` via: 

BindingResponseArray{ BindingResponseArgs{...} }

type BindingResponseArrayOutput 

type BindingResponseArrayOutput struct{ *pulumi.OutputState }

func (BindingResponseArrayOutput) ElementType 

func (BindingResponseArrayOutput) ElementType() reflect.Type

func (BindingResponseArrayOutput) Index 

func (o BindingResponseArrayOutput) Index(i pulumi.IntInput) BindingResponseOutput

func (BindingResponseArrayOutput) ToBindingResponseArrayOutput 

func (o BindingResponseArrayOutput) ToBindingResponseArrayOutput() BindingResponseArrayOutput

func (BindingResponseArrayOutput) ToBindingResponseArrayOutputWithContext 

func (o BindingResponseArrayOutput) ToBindingResponseArrayOutputWithContext(ctx context.Context) BindingResponseArrayOutput

type BindingResponseInput 

type BindingResponseInput interface {
	pulumi.Input

	ToBindingResponseOutput() BindingResponseOutput
	ToBindingResponseOutputWithContext(context.Context) BindingResponseOutput
}

BindingResponseInput is an input type that accepts BindingResponseArgs and BindingResponseOutput values. You can construct a concrete instance of `BindingResponseInput` via: 

BindingResponseArgs{...}

type BindingResponseOutput 

type BindingResponseOutput struct{ *pulumi.OutputState }

Associates `members` with a `role`.

func (BindingResponseOutput) BindingId 

func (o BindingResponseOutput) BindingId() pulumi.StringOutput

func (BindingResponseOutput) Condition 

func (o BindingResponseOutput) Condition() ExprResponseOutput

The condition that is associated with this binding. If the condition evaluates to `true`, then this binding applies to the current request. If the condition evaluates to `false`, then this binding does not apply to the current request. However, a different role binding might grant the same role to one or more of the members in this binding. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).

func (BindingResponseOutput) ElementType 

func (BindingResponseOutput) ElementType() reflect.Type

func (BindingResponseOutput) Members 

func (o BindingResponseOutput) Members() pulumi.StringArrayOutput

Specifies the identities requesting access for a Cloud Platform resource. `members` can have the following values: * `allUsers`: A special identifier that represents anyone who is on the internet; with or without a Google account. * `allAuthenticatedUsers`: A special identifier that represents anyone who is authenticated with a Google account or a service account. * `user:{emailid}`: An email address that represents a specific Google account. For example, `alice@example.com` . * `serviceAccount:{emailid}`: An email address that represents a service account. For example, `my-other-app@appspot.gserviceaccount.com`. * `group:{emailid}`: An email address that represents a Google group. For example, `admins@example.com`. * `deleted:user:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a user that has been recently deleted. For example, `alice@example.com?uid=123456789012345678901`. If the user is recovered, this value reverts to `user:{emailid}` and the recovered user retains the role in the binding. * `deleted:serviceAccount:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a service account that has been recently deleted. For example, `my-other-app@appspot.gserviceaccount.com?uid=123456789012345678901`. If the service account is undeleted, this value reverts to `serviceAccount:{emailid}` and the undeleted service account retains the role in the binding. * `deleted:group:{emailid}?uid={uniqueid}`: An email address (plus unique identifier) representing a Google group that has been recently deleted. For example, `admins@example.com?uid=123456789012345678901`. If the group is recovered, this value reverts to `group:{emailid}` and the recovered group retains the role in the binding. * `domain:{domain}`: The G Suite domain (primary) that represents all the users of that domain. For example, `google.com` or `example.com`.

func (BindingResponseOutput) Role 

func (o BindingResponseOutput) Role() pulumi.StringOutput

Role that is assigned to `members`. For example, `roles/viewer`, `roles/editor`, or `roles/owner`.

func (BindingResponseOutput) ToBindingResponseOutput 

func (o BindingResponseOutput) ToBindingResponseOutput() BindingResponseOutput

func (BindingResponseOutput) ToBindingResponseOutputWithContext 

func (o BindingResponseOutput) ToBindingResponseOutputWithContext(ctx context.Context) BindingResponseOutput

type CloudAuditOptions 

type CloudAuditOptions struct {
	// Information used by the Cloud Audit Logging pipeline.
	AuthorizationLoggingOptions *AuthorizationLoggingOptions `pulumi:"authorizationLoggingOptions"`
	// The log_name to populate in the Cloud Audit Record.
	LogName *string `pulumi:"logName"`
}

Write a Cloud Audit log

type CloudAuditOptionsArgs 

type CloudAuditOptionsArgs struct {
	// Information used by the Cloud Audit Logging pipeline.
	AuthorizationLoggingOptions AuthorizationLoggingOptionsPtrInput `pulumi:"authorizationLoggingOptions"`
	// The log_name to populate in the Cloud Audit Record.
	LogName pulumi.StringPtrInput `pulumi:"logName"`
}

Write a Cloud Audit log

func (CloudAuditOptionsArgs) ElementType 

func (CloudAuditOptionsArgs) ElementType() reflect.Type

func (CloudAuditOptionsArgs) ToCloudAuditOptionsOutput 

func (i CloudAuditOptionsArgs) ToCloudAuditOptionsOutput() CloudAuditOptionsOutput

func (CloudAuditOptionsArgs) ToCloudAuditOptionsOutputWithContext 

func (i CloudAuditOptionsArgs) ToCloudAuditOptionsOutputWithContext(ctx context.Context) CloudAuditOptionsOutput

func (CloudAuditOptionsArgs) ToCloudAuditOptionsPtrOutput 

func (i CloudAuditOptionsArgs) ToCloudAuditOptionsPtrOutput() CloudAuditOptionsPtrOutput

func (CloudAuditOptionsArgs) ToCloudAuditOptionsPtrOutputWithContext 

func (i CloudAuditOptionsArgs) ToCloudAuditOptionsPtrOutputWithContext(ctx context.Context) CloudAuditOptionsPtrOutput

type CloudAuditOptionsInput 

type CloudAuditOptionsInput interface {
	pulumi.Input

	ToCloudAuditOptionsOutput() CloudAuditOptionsOutput
	ToCloudAuditOptionsOutputWithContext(context.Context) CloudAuditOptionsOutput
}

CloudAuditOptionsInput is an input type that accepts CloudAuditOptionsArgs and CloudAuditOptionsOutput values. You can construct a concrete instance of `CloudAuditOptionsInput` via: 

CloudAuditOptionsArgs{...}

type CloudAuditOptionsOutput 

type CloudAuditOptionsOutput struct{ *pulumi.OutputState }

Write a Cloud Audit log

func (CloudAuditOptionsOutput) AuthorizationLoggingOptions 

func (o CloudAuditOptionsOutput) AuthorizationLoggingOptions() AuthorizationLoggingOptionsPtrOutput

Information used by the Cloud Audit Logging pipeline.

func (CloudAuditOptionsOutput) ElementType 

func (CloudAuditOptionsOutput) ElementType() reflect.Type

func (CloudAuditOptionsOutput) LogName 

func (o CloudAuditOptionsOutput) LogName() pulumi.StringPtrOutput

The log_name to populate in the Cloud Audit Record.

func (CloudAuditOptionsOutput) ToCloudAuditOptionsOutput 

func (o CloudAuditOptionsOutput) ToCloudAuditOptionsOutput() CloudAuditOptionsOutput

func (CloudAuditOptionsOutput) ToCloudAuditOptionsOutputWithContext 

func (o CloudAuditOptionsOutput) ToCloudAuditOptionsOutputWithContext(ctx context.Context) CloudAuditOptionsOutput

func (CloudAuditOptionsOutput) ToCloudAuditOptionsPtrOutput 

func (o CloudAuditOptionsOutput) ToCloudAuditOptionsPtrOutput() CloudAuditOptionsPtrOutput

func (CloudAuditOptionsOutput) ToCloudAuditOptionsPtrOutputWithContext 

func (o CloudAuditOptionsOutput) ToCloudAuditOptionsPtrOutputWithContext(ctx context.Context) CloudAuditOptionsPtrOutput

type CloudAuditOptionsPtrInput 

type CloudAuditOptionsPtrInput interface {
	pulumi.Input

	ToCloudAuditOptionsPtrOutput() CloudAuditOptionsPtrOutput
	ToCloudAuditOptionsPtrOutputWithContext(context.Context) CloudAuditOptionsPtrOutput
}

CloudAuditOptionsPtrInput is an input type that accepts CloudAuditOptionsArgs, CloudAuditOptionsPtr and CloudAuditOptionsPtrOutput values. You can construct a concrete instance of `CloudAuditOptionsPtrInput` via: 

        CloudAuditOptionsArgs{...}

or:

        nil

func CloudAuditOptionsPtr 

func CloudAuditOptionsPtr(v *CloudAuditOptionsArgs) CloudAuditOptionsPtrInput

type CloudAuditOptionsPtrOutput 

type CloudAuditOptionsPtrOutput struct{ *pulumi.OutputState }

func (CloudAuditOptionsPtrOutput) AuthorizationLoggingOptions 

func (o CloudAuditOptionsPtrOutput) AuthorizationLoggingOptions() AuthorizationLoggingOptionsPtrOutput

Information used by the Cloud Audit Logging pipeline.

func (CloudAuditOptionsPtrOutput) Elem 

func (o CloudAuditOptionsPtrOutput) Elem() CloudAuditOptionsOutput

func (CloudAuditOptionsPtrOutput) ElementType 

func (CloudAuditOptionsPtrOutput) ElementType() reflect.Type

func (CloudAuditOptionsPtrOutput) LogName 

func (o CloudAuditOptionsPtrOutput) LogName() pulumi.StringPtrOutput

The log_name to populate in the Cloud Audit Record.

func (CloudAuditOptionsPtrOutput) ToCloudAuditOptionsPtrOutput 

func (o CloudAuditOptionsPtrOutput) ToCloudAuditOptionsPtrOutput() CloudAuditOptionsPtrOutput

func (CloudAuditOptionsPtrOutput) ToCloudAuditOptionsPtrOutputWithContext 

func (o CloudAuditOptionsPtrOutput) ToCloudAuditOptionsPtrOutputWithContext(ctx context.Context) CloudAuditOptionsPtrOutput

type CloudAuditOptionsResponse 

type CloudAuditOptionsResponse struct {
	// Information used by the Cloud Audit Logging pipeline.
	AuthorizationLoggingOptions AuthorizationLoggingOptionsResponse `pulumi:"authorizationLoggingOptions"`
	// The log_name to populate in the Cloud Audit Record.
	LogName string `pulumi:"logName"`
}

Write a Cloud Audit log

type CloudAuditOptionsResponseArgs 

type CloudAuditOptionsResponseArgs struct {
	// Information used by the Cloud Audit Logging pipeline.
	AuthorizationLoggingOptions AuthorizationLoggingOptionsResponseInput `pulumi:"authorizationLoggingOptions"`
	// The log_name to populate in the Cloud Audit Record.
	LogName pulumi.StringInput `pulumi:"logName"`
}

Write a Cloud Audit log

func (CloudAuditOptionsResponseArgs) ElementType 

func (CloudAuditOptionsResponseArgs) ElementType() reflect.Type

func (CloudAuditOptionsResponseArgs) ToCloudAuditOptionsResponseOutput 

func (i CloudAuditOptionsResponseArgs) ToCloudAuditOptionsResponseOutput() CloudAuditOptionsResponseOutput

func (CloudAuditOptionsResponseArgs) ToCloudAuditOptionsResponseOutputWithContext 

func (i CloudAuditOptionsResponseArgs) ToCloudAuditOptionsResponseOutputWithContext(ctx context.Context) CloudAuditOptionsResponseOutput

type CloudAuditOptionsResponseInput 

type CloudAuditOptionsResponseInput interface {
	pulumi.Input

	ToCloudAuditOptionsResponseOutput() CloudAuditOptionsResponseOutput
	ToCloudAuditOptionsResponseOutputWithContext(context.Context) CloudAuditOptionsResponseOutput
}

CloudAuditOptionsResponseInput is an input type that accepts CloudAuditOptionsResponseArgs and CloudAuditOptionsResponseOutput values. You can construct a concrete instance of `CloudAuditOptionsResponseInput` via: 

CloudAuditOptionsResponseArgs{...}

type CloudAuditOptionsResponseOutput 

type CloudAuditOptionsResponseOutput struct{ *pulumi.OutputState }

Write a Cloud Audit log

func (CloudAuditOptionsResponseOutput) AuthorizationLoggingOptions 

func (o CloudAuditOptionsResponseOutput) AuthorizationLoggingOptions() AuthorizationLoggingOptionsResponseOutput

Information used by the Cloud Audit Logging pipeline.

func (CloudAuditOptionsResponseOutput) ElementType 

func (CloudAuditOptionsResponseOutput) ElementType() reflect.Type

func (CloudAuditOptionsResponseOutput) LogName 

func (o CloudAuditOptionsResponseOutput) LogName() pulumi.StringOutput

The log_name to populate in the Cloud Audit Record.

func (CloudAuditOptionsResponseOutput) ToCloudAuditOptionsResponseOutput 

func (o CloudAuditOptionsResponseOutput) ToCloudAuditOptionsResponseOutput() CloudAuditOptionsResponseOutput

func (CloudAuditOptionsResponseOutput) ToCloudAuditOptionsResponseOutputWithContext 

func (o CloudAuditOptionsResponseOutput) ToCloudAuditOptionsResponseOutputWithContext(ctx context.Context) CloudAuditOptionsResponseOutput

type Condition 

type Condition struct {
	// Trusted attributes supplied by the IAM system.
	Iam *string `pulumi:"iam"`
	// An operator to apply the subject with.
	Op *string `pulumi:"op"`
	// Trusted attributes discharged by the service.
	Svc *string `pulumi:"svc"`
	// Trusted attributes supplied by any service that owns resources and uses the IAM system for access control.
	Sys *string `pulumi:"sys"`
	// The objects of the condition.
	Values []string `pulumi:"values"`
}

A condition to be met.

type ConditionArgs 

type ConditionArgs struct {
	// Trusted attributes supplied by the IAM system.
	Iam pulumi.StringPtrInput `pulumi:"iam"`
	// An operator to apply the subject with.
	Op pulumi.StringPtrInput `pulumi:"op"`
	// Trusted attributes discharged by the service.
	Svc pulumi.StringPtrInput `pulumi:"svc"`
	// Trusted attributes supplied by any service that owns resources and uses the IAM system for access control.
	Sys pulumi.StringPtrInput `pulumi:"sys"`
	// The objects of the condition.
	Values pulumi.StringArrayInput `pulumi:"values"`
}

A condition to be met.

func (ConditionArgs) ElementType 

func (ConditionArgs) ElementType() reflect.Type

func (ConditionArgs) ToConditionOutput 

func (i ConditionArgs) ToConditionOutput() ConditionOutput

func (ConditionArgs) ToConditionOutputWithContext 

func (i ConditionArgs) ToConditionOutputWithContext(ctx context.Context) ConditionOutput

type ConditionArray 

type ConditionArray []ConditionInput

func (ConditionArray) ElementType 

func (ConditionArray) ElementType() reflect.Type

func (ConditionArray) ToConditionArrayOutput 

func (i ConditionArray) ToConditionArrayOutput() ConditionArrayOutput

func (ConditionArray) ToConditionArrayOutputWithContext 

func (i ConditionArray) ToConditionArrayOutputWithContext(ctx context.Context) ConditionArrayOutput

type ConditionArrayInput 

type ConditionArrayInput interface {
	pulumi.Input

	ToConditionArrayOutput() ConditionArrayOutput
	ToConditionArrayOutputWithContext(context.Context) ConditionArrayOutput
}

ConditionArrayInput is an input type that accepts ConditionArray and ConditionArrayOutput values. You can construct a concrete instance of `ConditionArrayInput` via: 

ConditionArray{ ConditionArgs{...} }

type ConditionArrayOutput 

type ConditionArrayOutput struct{ *pulumi.OutputState }

func (ConditionArrayOutput) ElementType 

func (ConditionArrayOutput) ElementType() reflect.Type

func (ConditionArrayOutput) Index 

func (o ConditionArrayOutput) Index(i pulumi.IntInput) ConditionOutput

func (ConditionArrayOutput) ToConditionArrayOutput 

func (o ConditionArrayOutput) ToConditionArrayOutput() ConditionArrayOutput

func (ConditionArrayOutput) ToConditionArrayOutputWithContext 

func (o ConditionArrayOutput) ToConditionArrayOutputWithContext(ctx context.Context) ConditionArrayOutput

type ConditionInput 

type ConditionInput interface {
	pulumi.Input

	ToConditionOutput() ConditionOutput
	ToConditionOutputWithContext(context.Context) ConditionOutput
}

ConditionInput is an input type that accepts ConditionArgs and ConditionOutput values. You can construct a concrete instance of `ConditionInput` via: 

ConditionArgs{...}

type ConditionOutput 

type ConditionOutput struct{ *pulumi.OutputState }

A condition to be met.

func (ConditionOutput) ElementType 

func (ConditionOutput) ElementType() reflect.Type

func (ConditionOutput) Iam 

func (o ConditionOutput) Iam() pulumi.StringPtrOutput

Trusted attributes supplied by the IAM system.

func (ConditionOutput) Op 

func (o ConditionOutput) Op() pulumi.StringPtrOutput

An operator to apply the subject with.

func (ConditionOutput) Svc 

func (o ConditionOutput) Svc() pulumi.StringPtrOutput

Trusted attributes discharged by the service.

func (ConditionOutput) Sys 

func (o ConditionOutput) Sys() pulumi.StringPtrOutput

Trusted attributes supplied by any service that owns resources and uses the IAM system for access control.

func (ConditionOutput) ToConditionOutput 

func (o ConditionOutput) ToConditionOutput() ConditionOutput

func (ConditionOutput) ToConditionOutputWithContext 

func (o ConditionOutput) ToConditionOutputWithContext(ctx context.Context) ConditionOutput

func (ConditionOutput) Values 

func (o ConditionOutput) Values() pulumi.StringArrayOutput

The objects of the condition.

type ConditionResponse 

type ConditionResponse struct {
	// Trusted attributes supplied by the IAM system.
	Iam string `pulumi:"iam"`
	// An operator to apply the subject with.
	Op string `pulumi:"op"`
	// Trusted attributes discharged by the service.
	Svc string `pulumi:"svc"`
	// Trusted attributes supplied by any service that owns resources and uses the IAM system for access control.
	Sys string `pulumi:"sys"`
	// The objects of the condition.
	Values []string `pulumi:"values"`
}

A condition to be met.

type ConditionResponseArgs 

type ConditionResponseArgs struct {
	// Trusted attributes supplied by the IAM system.
	Iam pulumi.StringInput `pulumi:"iam"`
	// An operator to apply the subject with.
	Op pulumi.StringInput `pulumi:"op"`
	// Trusted attributes discharged by the service.
	Svc pulumi.StringInput `pulumi:"svc"`
	// Trusted attributes supplied by any service that owns resources and uses the IAM system for access control.
	Sys pulumi.StringInput `pulumi:"sys"`
	// The objects of the condition.
	Values pulumi.StringArrayInput `pulumi:"values"`
}

A condition to be met.

func (ConditionResponseArgs) ElementType 

func (ConditionResponseArgs) ElementType() reflect.Type

func (ConditionResponseArgs) ToConditionResponseOutput 

func (i ConditionResponseArgs) ToConditionResponseOutput() ConditionResponseOutput

func (ConditionResponseArgs) ToConditionResponseOutputWithContext 

func (i ConditionResponseArgs) ToConditionResponseOutputWithContext(ctx context.Context) ConditionResponseOutput

type ConditionResponseArray 

type ConditionResponseArray []ConditionResponseInput

func (ConditionResponseArray) ElementType 

func (ConditionResponseArray) ElementType() reflect.Type

func (ConditionResponseArray) ToConditionResponseArrayOutput 

func (i ConditionResponseArray) ToConditionResponseArrayOutput() ConditionResponseArrayOutput

func (ConditionResponseArray) ToConditionResponseArrayOutputWithContext 

func (i ConditionResponseArray) ToConditionResponseArrayOutputWithContext(ctx context.Context) ConditionResponseArrayOutput

type ConditionResponseArrayInput 

type ConditionResponseArrayInput interface {
	pulumi.Input

	ToConditionResponseArrayOutput() ConditionResponseArrayOutput
	ToConditionResponseArrayOutputWithContext(context.Context) ConditionResponseArrayOutput
}

ConditionResponseArrayInput is an input type that accepts ConditionResponseArray and ConditionResponseArrayOutput values. You can construct a concrete instance of `ConditionResponseArrayInput` via: 

ConditionResponseArray{ ConditionResponseArgs{...} }

type ConditionResponseArrayOutput 

type ConditionResponseArrayOutput struct{ *pulumi.OutputState }

func (ConditionResponseArrayOutput) ElementType 

func (ConditionResponseArrayOutput) ElementType() reflect.Type

func (ConditionResponseArrayOutput) Index 

func (o ConditionResponseArrayOutput) Index(i pulumi.IntInput) ConditionResponseOutput

func (ConditionResponseArrayOutput) ToConditionResponseArrayOutput 

func (o ConditionResponseArrayOutput) ToConditionResponseArrayOutput() ConditionResponseArrayOutput

func (ConditionResponseArrayOutput) ToConditionResponseArrayOutputWithContext 

func (o ConditionResponseArrayOutput) ToConditionResponseArrayOutputWithContext(ctx context.Context) ConditionResponseArrayOutput

type ConditionResponseInput 

type ConditionResponseInput interface {
	pulumi.Input

	ToConditionResponseOutput() ConditionResponseOutput
	ToConditionResponseOutputWithContext(context.Context) ConditionResponseOutput
}

ConditionResponseInput is an input type that accepts ConditionResponseArgs and ConditionResponseOutput values. You can construct a concrete instance of `ConditionResponseInput` via: 

ConditionResponseArgs{...}

type ConditionResponseOutput 

type ConditionResponseOutput struct{ *pulumi.OutputState }

A condition to be met.

func (ConditionResponseOutput) ElementType 

func (ConditionResponseOutput) ElementType() reflect.Type

func (ConditionResponseOutput) Iam 

func (o ConditionResponseOutput) Iam() pulumi.StringOutput

Trusted attributes supplied by the IAM system.

func (ConditionResponseOutput) Op 

func (o ConditionResponseOutput) Op() pulumi.StringOutput

An operator to apply the subject with.

func (ConditionResponseOutput) Svc 

func (o ConditionResponseOutput) Svc() pulumi.StringOutput

Trusted attributes discharged by the service.

func (ConditionResponseOutput) Sys 

func (o ConditionResponseOutput) Sys() pulumi.StringOutput

Trusted attributes supplied by any service that owns resources and uses the IAM system for access control.

func (ConditionResponseOutput) ToConditionResponseOutput 

func (o ConditionResponseOutput) ToConditionResponseOutput() ConditionResponseOutput

func (ConditionResponseOutput) ToConditionResponseOutputWithContext 

func (o ConditionResponseOutput) ToConditionResponseOutputWithContext(ctx context.Context) ConditionResponseOutput

func (ConditionResponseOutput) Values 

func (o ConditionResponseOutput) Values() pulumi.StringArrayOutput

The objects of the condition.

type Config added in v0.3.0 

type Config struct {
	pulumi.CustomResourceState

	// The creation time.
	CreateTime pulumi.StringOutput `pulumi:"createTime"`
	// The description of the game server config.
	Description pulumi.StringOutput `pulumi:"description"`
	// FleetConfig contains a list of Agones fleet specs. Only one FleetConfig is allowed.
	FleetConfigs FleetConfigResponseArrayOutput `pulumi:"fleetConfigs"`
	// The labels associated with this game server config. Each label is a key-value pair.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// The resource name of the game server config, in the following form: `projects/{project}/locations/{location}/gameServerDeployments/{deployment}/configs/{config}`. For example, `projects/my-project/locations/global/gameServerDeployments/my-game/configs/my-config`.
	Name pulumi.StringOutput `pulumi:"name"`
	// The autoscaling settings.
	ScalingConfigs ScalingConfigResponseArrayOutput `pulumi:"scalingConfigs"`
	// The last-modified time.
	UpdateTime pulumi.StringOutput `pulumi:"updateTime"`
}

Creates a new game server config in a given project, location, and game server deployment. Game server configs are immutable, and are not applied until referenced in the game server deployment rollout resource.

func GetConfig added in v0.3.0 

func GetConfig(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *ConfigState, opts ...pulumi.ResourceOption) (*Config, error)

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

func NewConfig added in v0.3.0 

func NewConfig(ctx *pulumi.Context,
	name string, args *ConfigArgs, opts ...pulumi.ResourceOption) (*Config, error)

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

func (*Config) ElementType added in v0.3.0 

func (*Config) ElementType() reflect.Type

func (*Config) ToConfigOutput added in v0.3.0 

func (i *Config) ToConfigOutput() ConfigOutput

func (*Config) ToConfigOutputWithContext added in v0.3.0 

func (i *Config) ToConfigOutputWithContext(ctx context.Context) ConfigOutput

type ConfigArgs added in v0.3.0 

type ConfigArgs struct {
	ConfigId pulumi.StringInput
	// The description of the game server config.
	Description pulumi.StringPtrInput
	// FleetConfig contains a list of Agones fleet specs. Only one FleetConfig is allowed.
	FleetConfigs           FleetConfigArrayInput
	GameServerDeploymentId pulumi.StringInput
	// The labels associated with this game server config. Each label is a key-value pair.
	Labels   pulumi.StringMapInput
	Location pulumi.StringInput
	// The resource name of the game server config, in the following form: `projects/{project}/locations/{location}/gameServerDeployments/{deployment}/configs/{config}`. For example, `projects/my-project/locations/global/gameServerDeployments/my-game/configs/my-config`.
	Name    pulumi.StringPtrInput
	Project pulumi.StringInput
	// The autoscaling settings.
	ScalingConfigs ScalingConfigArrayInput
}

The set of arguments for constructing a Config resource.

func (ConfigArgs) ElementType added in v0.3.0 

func (ConfigArgs) ElementType() reflect.Type

type ConfigInput added in v0.3.0 

type ConfigInput interface {
	pulumi.Input

	ToConfigOutput() ConfigOutput
	ToConfigOutputWithContext(ctx context.Context) ConfigOutput
}

type ConfigOutput added in v0.3.0 

type ConfigOutput struct {
	*pulumi.OutputState
}

func (ConfigOutput) ElementType added in v0.3.0 

func (ConfigOutput) ElementType() reflect.Type

func (ConfigOutput) ToConfigOutput added in v0.3.0 

func (o ConfigOutput) ToConfigOutput() ConfigOutput

func (ConfigOutput) ToConfigOutputWithContext added in v0.3.0 

func (o ConfigOutput) ToConfigOutputWithContext(ctx context.Context) ConfigOutput

type ConfigState added in v0.3.0 

type ConfigState struct {
	// The creation time.
	CreateTime pulumi.StringPtrInput
	// The description of the game server config.
	Description pulumi.StringPtrInput
	// FleetConfig contains a list of Agones fleet specs. Only one FleetConfig is allowed.
	FleetConfigs FleetConfigResponseArrayInput
	// The labels associated with this game server config. Each label is a key-value pair.
	Labels pulumi.StringMapInput
	// The resource name of the game server config, in the following form: `projects/{project}/locations/{location}/gameServerDeployments/{deployment}/configs/{config}`. For example, `projects/my-project/locations/global/gameServerDeployments/my-game/configs/my-config`.
	Name pulumi.StringPtrInput
	// The autoscaling settings.
	ScalingConfigs ScalingConfigResponseArrayInput
	// The last-modified time.
	UpdateTime pulumi.StringPtrInput
}

func (ConfigState) ElementType added in v0.3.0 

func (ConfigState) ElementType() reflect.Type

type CounterOptions 

type CounterOptions struct {
	// Custom fields.
	CustomFields []CustomField `pulumi:"customFields"`
	// The field value to attribute.
	Field *string `pulumi:"field"`
	// The metric to update.
	Metric *string `pulumi:"metric"`
}

Increment a streamz counter with the specified metric and field names. Metric names should start with a '/', generally be lowercase-only, and end in "_count". Field names should not contain an initial slash. The actual exported metric names will have "/iam/policy" prepended. Field names correspond to IAM request parameters and field values are their respective values. Supported field names: - "authority", which is "[token]" if IAMContext.token is present, otherwise the value of IAMContext.authority_selector if present, and otherwise a representation of IAMContext.principal; or - "iam_principal", a representation of IAMContext.principal even if a token or authority selector is present; or - "" (empty string), resulting in a counter with no fields. Examples: counter { metric: "/debug_access_count" field: "iam_principal" } ==> increment counter /iam/policy/debug_access_count {iam_principal=[value of IAMContext.principal]}

type CounterOptionsArgs 

type CounterOptionsArgs struct {
	// Custom fields.
	CustomFields CustomFieldArrayInput `pulumi:"customFields"`
	// The field value to attribute.
	Field pulumi.StringPtrInput `pulumi:"field"`
	// The metric to update.
	Metric pulumi.StringPtrInput `pulumi:"metric"`
}

Increment a streamz counter with the specified metric and field names. Metric names should start with a '/', generally be lowercase-only, and end in "_count". Field names should not contain an initial slash. The actual exported metric names will have "/iam/policy" prepended. Field names correspond to IAM request parameters and field values are their respective values. Supported field names: - "authority", which is "[token]" if IAMContext.token is present, otherwise the value of IAMContext.authority_selector if present, and otherwise a representation of IAMContext.principal; or - "iam_principal", a representation of IAMContext.principal even if a token or authority selector is present; or - "" (empty string), resulting in a counter with no fields. Examples: counter { metric: "/debug_access_count" field: "iam_principal" } ==> increment counter /iam/policy/debug_access_count {iam_principal=[value of IAMContext.principal]}

func (CounterOptionsArgs) ElementType 

func (CounterOptionsArgs) ElementType() reflect.Type

func (CounterOptionsArgs) ToCounterOptionsOutput 

func (i CounterOptionsArgs) ToCounterOptionsOutput() CounterOptionsOutput

func (CounterOptionsArgs) ToCounterOptionsOutputWithContext 

func (i CounterOptionsArgs) ToCounterOptionsOutputWithContext(ctx context.Context) CounterOptionsOutput

func (CounterOptionsArgs) ToCounterOptionsPtrOutput 

func (i CounterOptionsArgs) ToCounterOptionsPtrOutput() CounterOptionsPtrOutput

func (CounterOptionsArgs) ToCounterOptionsPtrOutputWithContext 

func (i CounterOptionsArgs) ToCounterOptionsPtrOutputWithContext(ctx context.Context) CounterOptionsPtrOutput

type CounterOptionsInput 

type CounterOptionsInput interface {
	pulumi.Input

	ToCounterOptionsOutput() CounterOptionsOutput
	ToCounterOptionsOutputWithContext(context.Context) CounterOptionsOutput
}

CounterOptionsInput is an input type that accepts CounterOptionsArgs and CounterOptionsOutput values. You can construct a concrete instance of `CounterOptionsInput` via: 

CounterOptionsArgs{...}

type CounterOptionsOutput 

type CounterOptionsOutput struct{ *pulumi.OutputState }

Increment a streamz counter with the specified metric and field names. Metric names should start with a '/', generally be lowercase-only, and end in "_count". Field names should not contain an initial slash. The actual exported metric names will have "/iam/policy" prepended. Field names correspond to IAM request parameters and field values are their respective values. Supported field names: - "authority", which is "[token]" if IAMContext.token is present, otherwise the value of IAMContext.authority_selector if present, and otherwise a representation of IAMContext.principal; or - "iam_principal", a representation of IAMContext.principal even if a token or authority selector is present; or - "" (empty string), resulting in a counter with no fields. Examples: counter { metric: "/debug_access_count" field: "iam_principal" } ==> increment counter /iam/policy/debug_access_count {iam_principal=[value of IAMContext.principal]}

func (CounterOptionsOutput) CustomFields 

func (o CounterOptionsOutput) CustomFields() CustomFieldArrayOutput

Custom fields.

func (CounterOptionsOutput) ElementType 

func (CounterOptionsOutput) ElementType() reflect.Type

func (CounterOptionsOutput) Field 

func (o CounterOptionsOutput) Field() pulumi.StringPtrOutput

The field value to attribute.

func (CounterOptionsOutput) Metric 

func (o CounterOptionsOutput) Metric() pulumi.StringPtrOutput

The metric to update.

func (CounterOptionsOutput) ToCounterOptionsOutput 

func (o CounterOptionsOutput) ToCounterOptionsOutput() CounterOptionsOutput

func (CounterOptionsOutput) ToCounterOptionsOutputWithContext 

func (o CounterOptionsOutput) ToCounterOptionsOutputWithContext(ctx context.Context) CounterOptionsOutput

func (CounterOptionsOutput) ToCounterOptionsPtrOutput 

func (o CounterOptionsOutput) ToCounterOptionsPtrOutput() CounterOptionsPtrOutput

func (CounterOptionsOutput) ToCounterOptionsPtrOutputWithContext 

func (o CounterOptionsOutput) ToCounterOptionsPtrOutputWithContext(ctx context.Context) CounterOptionsPtrOutput

type CounterOptionsPtrInput 

type CounterOptionsPtrInput interface {
	pulumi.Input

	ToCounterOptionsPtrOutput() CounterOptionsPtrOutput
	ToCounterOptionsPtrOutputWithContext(context.Context) CounterOptionsPtrOutput
}

CounterOptionsPtrInput is an input type that accepts CounterOptionsArgs, CounterOptionsPtr and CounterOptionsPtrOutput values. You can construct a concrete instance of `CounterOptionsPtrInput` via: 

        CounterOptionsArgs{...}

or:

        nil

func CounterOptionsPtr 

func CounterOptionsPtr(v *CounterOptionsArgs) CounterOptionsPtrInput

type CounterOptionsPtrOutput 

type CounterOptionsPtrOutput struct{ *pulumi.OutputState }

func (CounterOptionsPtrOutput) CustomFields 

func (o CounterOptionsPtrOutput) CustomFields() CustomFieldArrayOutput

Custom fields.

func (CounterOptionsPtrOutput) Elem 

func (o CounterOptionsPtrOutput) Elem() CounterOptionsOutput

func (CounterOptionsPtrOutput) ElementType 

func (CounterOptionsPtrOutput) ElementType() reflect.Type

func (CounterOptionsPtrOutput) Field 

func (o CounterOptionsPtrOutput) Field() pulumi.StringPtrOutput

The field value to attribute.

func (CounterOptionsPtrOutput) Metric 

func (o CounterOptionsPtrOutput) Metric() pulumi.StringPtrOutput

The metric to update.

func (CounterOptionsPtrOutput) ToCounterOptionsPtrOutput 

func (o CounterOptionsPtrOutput) ToCounterOptionsPtrOutput() CounterOptionsPtrOutput

func (CounterOptionsPtrOutput) ToCounterOptionsPtrOutputWithContext 

func (o CounterOptionsPtrOutput) ToCounterOptionsPtrOutputWithContext(ctx context.Context) CounterOptionsPtrOutput

type CounterOptionsResponse 

type CounterOptionsResponse struct {
	// Custom fields.
	CustomFields []CustomFieldResponse `pulumi:"customFields"`
	// The field value to attribute.
	Field string `pulumi:"field"`
	// The metric to update.
	Metric string `pulumi:"metric"`
}

Increment a streamz counter with the specified metric and field names. Metric names should start with a '/', generally be lowercase-only, and end in "_count". Field names should not contain an initial slash. The actual exported metric names will have "/iam/policy" prepended. Field names correspond to IAM request parameters and field values are their respective values. Supported field names: - "authority", which is "[token]" if IAMContext.token is present, otherwise the value of IAMContext.authority_selector if present, and otherwise a representation of IAMContext.principal; or - "iam_principal", a representation of IAMContext.principal even if a token or authority selector is present; or - "" (empty string), resulting in a counter with no fields. Examples: counter { metric: "/debug_access_count" field: "iam_principal" } ==> increment counter /iam/policy/debug_access_count {iam_principal=[value of IAMContext.principal]}

type CounterOptionsResponseArgs 

type CounterOptionsResponseArgs struct {
	// Custom fields.
	CustomFields CustomFieldResponseArrayInput `pulumi:"customFields"`
	// The field value to attribute.
	Field pulumi.StringInput `pulumi:"field"`
	// The metric to update.
	Metric pulumi.StringInput `pulumi:"metric"`
}

Increment a streamz counter with the specified metric and field names. Metric names should start with a '/', generally be lowercase-only, and end in "_count". Field names should not contain an initial slash. The actual exported metric names will have "/iam/policy" prepended. Field names correspond to IAM request parameters and field values are their respective values. Supported field names: - "authority", which is "[token]" if IAMContext.token is present, otherwise the value of IAMContext.authority_selector if present, and otherwise a representation of IAMContext.principal; or - "iam_principal", a representation of IAMContext.principal even if a token or authority selector is present; or - "" (empty string), resulting in a counter with no fields. Examples: counter { metric: "/debug_access_count" field: "iam_principal" } ==> increment counter /iam/policy/debug_access_count {iam_principal=[value of IAMContext.principal]}

func (CounterOptionsResponseArgs) ElementType 

func (CounterOptionsResponseArgs) ElementType() reflect.Type

func (CounterOptionsResponseArgs) ToCounterOptionsResponseOutput 

func (i CounterOptionsResponseArgs) ToCounterOptionsResponseOutput() CounterOptionsResponseOutput

func (CounterOptionsResponseArgs) ToCounterOptionsResponseOutputWithContext 

func (i CounterOptionsResponseArgs) ToCounterOptionsResponseOutputWithContext(ctx context.Context) CounterOptionsResponseOutput

type CounterOptionsResponseInput 

type CounterOptionsResponseInput interface {
	pulumi.Input

	ToCounterOptionsResponseOutput() CounterOptionsResponseOutput
	ToCounterOptionsResponseOutputWithContext(context.Context) CounterOptionsResponseOutput
}

CounterOptionsResponseInput is an input type that accepts CounterOptionsResponseArgs and CounterOptionsResponseOutput values. You can construct a concrete instance of `CounterOptionsResponseInput` via: 

CounterOptionsResponseArgs{...}

type CounterOptionsResponseOutput 

type CounterOptionsResponseOutput struct{ *pulumi.OutputState }

Increment a streamz counter with the specified metric and field names. Metric names should start with a '/', generally be lowercase-only, and end in "_count". Field names should not contain an initial slash. The actual exported metric names will have "/iam/policy" prepended. Field names correspond to IAM request parameters and field values are their respective values. Supported field names: - "authority", which is "[token]" if IAMContext.token is present, otherwise the value of IAMContext.authority_selector if present, and otherwise a representation of IAMContext.principal; or - "iam_principal", a representation of IAMContext.principal even if a token or authority selector is present; or - "" (empty string), resulting in a counter with no fields. Examples: counter { metric: "/debug_access_count" field: "iam_principal" } ==> increment counter /iam/policy/debug_access_count {iam_principal=[value of IAMContext.principal]}

func (CounterOptionsResponseOutput) CustomFields 

func (o CounterOptionsResponseOutput) CustomFields() CustomFieldResponseArrayOutput

Custom fields.

func (CounterOptionsResponseOutput) ElementType 

func (CounterOptionsResponseOutput) ElementType() reflect.Type

func (CounterOptionsResponseOutput) Field 

func (o CounterOptionsResponseOutput) Field() pulumi.StringOutput

The field value to attribute.

func (CounterOptionsResponseOutput) Metric 

func (o CounterOptionsResponseOutput) Metric() pulumi.StringOutput

The metric to update.

func (CounterOptionsResponseOutput) ToCounterOptionsResponseOutput 

func (o CounterOptionsResponseOutput) ToCounterOptionsResponseOutput() CounterOptionsResponseOutput

func (CounterOptionsResponseOutput) ToCounterOptionsResponseOutputWithContext 

func (o CounterOptionsResponseOutput) ToCounterOptionsResponseOutputWithContext(ctx context.Context) CounterOptionsResponseOutput

type CustomField 

type CustomField struct {
	// Name is the field name.
	Name *string `pulumi:"name"`
	// Value is the field value. It is important that in contrast to the CounterOptions.field, the value here is a constant that is not derived from the IAMContext.
	Value *string `pulumi:"value"`
}

Custom fields. These can be used to create a counter with arbitrary field/value pairs. See: go/rpcsp-custom-fields.

type CustomFieldArgs 

type CustomFieldArgs struct {
	// Name is the field name.
	Name pulumi.StringPtrInput `pulumi:"name"`
	// Value is the field value. It is important that in contrast to the CounterOptions.field, the value here is a constant that is not derived from the IAMContext.
	Value pulumi.StringPtrInput `pulumi:"value"`
}

Custom fields. These can be used to create a counter with arbitrary field/value pairs. See: go/rpcsp-custom-fields.

func (CustomFieldArgs) ElementType 

func (CustomFieldArgs) ElementType() reflect.Type

func (CustomFieldArgs) ToCustomFieldOutput 

func (i CustomFieldArgs) ToCustomFieldOutput() CustomFieldOutput

func (CustomFieldArgs) ToCustomFieldOutputWithContext 

func (i CustomFieldArgs) ToCustomFieldOutputWithContext(ctx context.Context) CustomFieldOutput

type CustomFieldArray 

type CustomFieldArray []CustomFieldInput

func (CustomFieldArray) ElementType 

func (CustomFieldArray) ElementType() reflect.Type

func (CustomFieldArray) ToCustomFieldArrayOutput 

func (i CustomFieldArray) ToCustomFieldArrayOutput() CustomFieldArrayOutput

func (CustomFieldArray) ToCustomFieldArrayOutputWithContext 

func (i CustomFieldArray) ToCustomFieldArrayOutputWithContext(ctx context.Context) CustomFieldArrayOutput

type CustomFieldArrayInput 

type CustomFieldArrayInput interface {
	pulumi.Input

	ToCustomFieldArrayOutput() CustomFieldArrayOutput
	ToCustomFieldArrayOutputWithContext(context.Context) CustomFieldArrayOutput
}

CustomFieldArrayInput is an input type that accepts CustomFieldArray and CustomFieldArrayOutput values. You can construct a concrete instance of `CustomFieldArrayInput` via: 

CustomFieldArray{ CustomFieldArgs{...} }

type CustomFieldArrayOutput 

type CustomFieldArrayOutput struct{ *pulumi.OutputState }

func (CustomFieldArrayOutput) ElementType 

func (CustomFieldArrayOutput) ElementType() reflect.Type

func (CustomFieldArrayOutput) Index 

func (o CustomFieldArrayOutput) Index(i pulumi.IntInput) CustomFieldOutput

func (CustomFieldArrayOutput) ToCustomFieldArrayOutput 

func (o CustomFieldArrayOutput) ToCustomFieldArrayOutput() CustomFieldArrayOutput

func (CustomFieldArrayOutput) ToCustomFieldArrayOutputWithContext 

func (o CustomFieldArrayOutput) ToCustomFieldArrayOutputWithContext(ctx context.Context) CustomFieldArrayOutput

type CustomFieldInput 

type CustomFieldInput interface {
	pulumi.Input

	ToCustomFieldOutput() CustomFieldOutput
	ToCustomFieldOutputWithContext(context.Context) CustomFieldOutput
}

CustomFieldInput is an input type that accepts CustomFieldArgs and CustomFieldOutput values. You can construct a concrete instance of `CustomFieldInput` via: 

CustomFieldArgs{...}

type CustomFieldOutput 

type CustomFieldOutput struct{ *pulumi.OutputState }

Custom fields. These can be used to create a counter with arbitrary field/value pairs. See: go/rpcsp-custom-fields.

func (CustomFieldOutput) ElementType 

func (CustomFieldOutput) ElementType() reflect.Type

func (CustomFieldOutput) Name 

func (o CustomFieldOutput) Name() pulumi.StringPtrOutput

Name is the field name.

func (CustomFieldOutput) ToCustomFieldOutput 

func (o CustomFieldOutput) ToCustomFieldOutput() CustomFieldOutput

func (CustomFieldOutput) ToCustomFieldOutputWithContext 

func (o CustomFieldOutput) ToCustomFieldOutputWithContext(ctx context.Context) CustomFieldOutput

func (CustomFieldOutput) Value 

func (o CustomFieldOutput) Value() pulumi.StringPtrOutput

Value is the field value. It is important that in contrast to the CounterOptions.field, the value here is a constant that is not derived from the IAMContext.

type CustomFieldResponse 

type CustomFieldResponse struct {
	// Name is the field name.
	Name string `pulumi:"name"`
	// Value is the field value. It is important that in contrast to the CounterOptions.field, the value here is a constant that is not derived from the IAMContext.
	Value string `pulumi:"value"`
}

Custom fields. These can be used to create a counter with arbitrary field/value pairs. See: go/rpcsp-custom-fields.

type CustomFieldResponseArgs 

type CustomFieldResponseArgs struct {
	// Name is the field name.
	Name pulumi.StringInput `pulumi:"name"`
	// Value is the field value. It is important that in contrast to the CounterOptions.field, the value here is a constant that is not derived from the IAMContext.
	Value pulumi.StringInput `pulumi:"value"`
}

Custom fields. These can be used to create a counter with arbitrary field/value pairs. See: go/rpcsp-custom-fields.

func (CustomFieldResponseArgs) ElementType 

func (CustomFieldResponseArgs) ElementType() reflect.Type

func (CustomFieldResponseArgs) ToCustomFieldResponseOutput 

func (i CustomFieldResponseArgs) ToCustomFieldResponseOutput() CustomFieldResponseOutput

func (CustomFieldResponseArgs) ToCustomFieldResponseOutputWithContext 

func (i CustomFieldResponseArgs) ToCustomFieldResponseOutputWithContext(ctx context.Context) CustomFieldResponseOutput

type CustomFieldResponseArray 

type CustomFieldResponseArray []CustomFieldResponseInput

func (CustomFieldResponseArray) ElementType 

func (CustomFieldResponseArray) ElementType() reflect.Type

func (CustomFieldResponseArray) ToCustomFieldResponseArrayOutput 

func (i CustomFieldResponseArray) ToCustomFieldResponseArrayOutput() CustomFieldResponseArrayOutput

func (CustomFieldResponseArray) ToCustomFieldResponseArrayOutputWithContext 

func (i CustomFieldResponseArray) ToCustomFieldResponseArrayOutputWithContext(ctx context.Context) CustomFieldResponseArrayOutput

type CustomFieldResponseArrayInput 

type CustomFieldResponseArrayInput interface {
	pulumi.Input

	ToCustomFieldResponseArrayOutput() CustomFieldResponseArrayOutput
	ToCustomFieldResponseArrayOutputWithContext(context.Context) CustomFieldResponseArrayOutput
}

CustomFieldResponseArrayInput is an input type that accepts CustomFieldResponseArray and CustomFieldResponseArrayOutput values. You can construct a concrete instance of `CustomFieldResponseArrayInput` via: 

CustomFieldResponseArray{ CustomFieldResponseArgs{...} }

type CustomFieldResponseArrayOutput 

type CustomFieldResponseArrayOutput struct{ *pulumi.OutputState }

func (CustomFieldResponseArrayOutput) ElementType 

func (CustomFieldResponseArrayOutput) ElementType() reflect.Type

func (CustomFieldResponseArrayOutput) Index 

func (o CustomFieldResponseArrayOutput) Index(i pulumi.IntInput) CustomFieldResponseOutput

func (CustomFieldResponseArrayOutput) ToCustomFieldResponseArrayOutput 

func (o CustomFieldResponseArrayOutput) ToCustomFieldResponseArrayOutput() CustomFieldResponseArrayOutput

func (CustomFieldResponseArrayOutput) ToCustomFieldResponseArrayOutputWithContext 

func (o CustomFieldResponseArrayOutput) ToCustomFieldResponseArrayOutputWithContext(ctx context.Context) CustomFieldResponseArrayOutput

type CustomFieldResponseInput 

type CustomFieldResponseInput interface {
	pulumi.Input

	ToCustomFieldResponseOutput() CustomFieldResponseOutput
	ToCustomFieldResponseOutputWithContext(context.Context) CustomFieldResponseOutput
}

CustomFieldResponseInput is an input type that accepts CustomFieldResponseArgs and CustomFieldResponseOutput values. You can construct a concrete instance of `CustomFieldResponseInput` via: 

CustomFieldResponseArgs{...}

type CustomFieldResponseOutput 

type CustomFieldResponseOutput struct{ *pulumi.OutputState }

Custom fields. These can be used to create a counter with arbitrary field/value pairs. See: go/rpcsp-custom-fields.

func (CustomFieldResponseOutput) ElementType 

func (CustomFieldResponseOutput) ElementType() reflect.Type

func (CustomFieldResponseOutput) Name 

func (o CustomFieldResponseOutput) Name() pulumi.StringOutput

Name is the field name.

func (CustomFieldResponseOutput) ToCustomFieldResponseOutput 

func (o CustomFieldResponseOutput) ToCustomFieldResponseOutput() CustomFieldResponseOutput

func (CustomFieldResponseOutput) ToCustomFieldResponseOutputWithContext 

func (o CustomFieldResponseOutput) ToCustomFieldResponseOutputWithContext(ctx context.Context) CustomFieldResponseOutput

func (CustomFieldResponseOutput) Value 

func (o CustomFieldResponseOutput) Value() pulumi.StringOutput

Value is the field value. It is important that in contrast to the CounterOptions.field, the value here is a constant that is not derived from the IAMContext.

type DataAccessOptions 

type DataAccessOptions struct {
	LogMode *string `pulumi:"logMode"`
}

Write a Data Access (Gin) log

type DataAccessOptionsArgs 

type DataAccessOptionsArgs struct {
	LogMode pulumi.StringPtrInput `pulumi:"logMode"`
}

Write a Data Access (Gin) log

func (DataAccessOptionsArgs) ElementType 

func (DataAccessOptionsArgs) ElementType() reflect.Type

func (DataAccessOptionsArgs) ToDataAccessOptionsOutput 

func (i DataAccessOptionsArgs) ToDataAccessOptionsOutput() DataAccessOptionsOutput

func (DataAccessOptionsArgs) ToDataAccessOptionsOutputWithContext 

func (i DataAccessOptionsArgs) ToDataAccessOptionsOutputWithContext(ctx context.Context) DataAccessOptionsOutput

func (DataAccessOptionsArgs) ToDataAccessOptionsPtrOutput 

func (i DataAccessOptionsArgs) ToDataAccessOptionsPtrOutput() DataAccessOptionsPtrOutput

func (DataAccessOptionsArgs) ToDataAccessOptionsPtrOutputWithContext 

func (i DataAccessOptionsArgs) ToDataAccessOptionsPtrOutputWithContext(ctx context.Context) DataAccessOptionsPtrOutput

type DataAccessOptionsInput 

type DataAccessOptionsInput interface {
	pulumi.Input

	ToDataAccessOptionsOutput() DataAccessOptionsOutput
	ToDataAccessOptionsOutputWithContext(context.Context) DataAccessOptionsOutput
}

DataAccessOptionsInput is an input type that accepts DataAccessOptionsArgs and DataAccessOptionsOutput values. You can construct a concrete instance of `DataAccessOptionsInput` via: 

DataAccessOptionsArgs{...}

type DataAccessOptionsOutput 

type DataAccessOptionsOutput struct{ *pulumi.OutputState }

Write a Data Access (Gin) log

func (DataAccessOptionsOutput) ElementType 

func (DataAccessOptionsOutput) ElementType() reflect.Type

func (DataAccessOptionsOutput) LogMode 

func (o DataAccessOptionsOutput) LogMode() pulumi.StringPtrOutput

func (DataAccessOptionsOutput) ToDataAccessOptionsOutput 

func (o DataAccessOptionsOutput) ToDataAccessOptionsOutput() DataAccessOptionsOutput

func (DataAccessOptionsOutput) ToDataAccessOptionsOutputWithContext 

func (o DataAccessOptionsOutput) ToDataAccessOptionsOutputWithContext(ctx context.Context) DataAccessOptionsOutput

func (DataAccessOptionsOutput) ToDataAccessOptionsPtrOutput 

func (o DataAccessOptionsOutput) ToDataAccessOptionsPtrOutput() DataAccessOptionsPtrOutput

func (DataAccessOptionsOutput) ToDataAccessOptionsPtrOutputWithContext 

func (o DataAccessOptionsOutput) ToDataAccessOptionsPtrOutputWithContext(ctx context.Context) DataAccessOptionsPtrOutput

type DataAccessOptionsPtrInput 

type DataAccessOptionsPtrInput interface {
	pulumi.Input

	ToDataAccessOptionsPtrOutput() DataAccessOptionsPtrOutput
	ToDataAccessOptionsPtrOutputWithContext(context.Context) DataAccessOptionsPtrOutput
}

DataAccessOptionsPtrInput is an input type that accepts DataAccessOptionsArgs, DataAccessOptionsPtr and DataAccessOptionsPtrOutput values. You can construct a concrete instance of `DataAccessOptionsPtrInput` via: 

        DataAccessOptionsArgs{...}

or:

        nil

func DataAccessOptionsPtr 

func DataAccessOptionsPtr(v *DataAccessOptionsArgs) DataAccessOptionsPtrInput

type DataAccessOptionsPtrOutput 

type DataAccessOptionsPtrOutput struct{ *pulumi.OutputState }

func (DataAccessOptionsPtrOutput) Elem 

func (o DataAccessOptionsPtrOutput) Elem() DataAccessOptionsOutput

func (DataAccessOptionsPtrOutput) ElementType 

func (DataAccessOptionsPtrOutput) ElementType() reflect.Type

func (DataAccessOptionsPtrOutput) LogMode 

func (o DataAccessOptionsPtrOutput) LogMode() pulumi.StringPtrOutput

func (DataAccessOptionsPtrOutput) ToDataAccessOptionsPtrOutput 

func (o DataAccessOptionsPtrOutput) ToDataAccessOptionsPtrOutput() DataAccessOptionsPtrOutput

func (DataAccessOptionsPtrOutput) ToDataAccessOptionsPtrOutputWithContext 

func (o DataAccessOptionsPtrOutput) ToDataAccessOptionsPtrOutputWithContext(ctx context.Context) DataAccessOptionsPtrOutput

type DataAccessOptionsResponse 

type DataAccessOptionsResponse struct {
	LogMode string `pulumi:"logMode"`
}

Write a Data Access (Gin) log

type DataAccessOptionsResponseArgs 

type DataAccessOptionsResponseArgs struct {
	LogMode pulumi.StringInput `pulumi:"logMode"`
}

Write a Data Access (Gin) log

func (DataAccessOptionsResponseArgs) ElementType 

func (DataAccessOptionsResponseArgs) ElementType() reflect.Type

func (DataAccessOptionsResponseArgs) ToDataAccessOptionsResponseOutput 

func (i DataAccessOptionsResponseArgs) ToDataAccessOptionsResponseOutput() DataAccessOptionsResponseOutput

func (DataAccessOptionsResponseArgs) ToDataAccessOptionsResponseOutputWithContext 

func (i DataAccessOptionsResponseArgs) ToDataAccessOptionsResponseOutputWithContext(ctx context.Context) DataAccessOptionsResponseOutput

type DataAccessOptionsResponseInput 

type DataAccessOptionsResponseInput interface {
	pulumi.Input

	ToDataAccessOptionsResponseOutput() DataAccessOptionsResponseOutput
	ToDataAccessOptionsResponseOutputWithContext(context.Context) DataAccessOptionsResponseOutput
}

DataAccessOptionsResponseInput is an input type that accepts DataAccessOptionsResponseArgs and DataAccessOptionsResponseOutput values. You can construct a concrete instance of `DataAccessOptionsResponseInput` via: 

DataAccessOptionsResponseArgs{...}

type DataAccessOptionsResponseOutput 

type DataAccessOptionsResponseOutput struct{ *pulumi.OutputState }

Write a Data Access (Gin) log

func (DataAccessOptionsResponseOutput) ElementType 

func (DataAccessOptionsResponseOutput) ElementType() reflect.Type

func (DataAccessOptionsResponseOutput) LogMode 

func (o DataAccessOptionsResponseOutput) LogMode() pulumi.StringOutput

func (DataAccessOptionsResponseOutput) ToDataAccessOptionsResponseOutput 

func (o DataAccessOptionsResponseOutput) ToDataAccessOptionsResponseOutput() DataAccessOptionsResponseOutput

func (DataAccessOptionsResponseOutput) ToDataAccessOptionsResponseOutputWithContext 

func (o DataAccessOptionsResponseOutput) ToDataAccessOptionsResponseOutputWithContext(ctx context.Context) DataAccessOptionsResponseOutput

type Expr 

type Expr struct {
	// Optional. Description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
	Description *string `pulumi:"description"`
	// Textual representation of an expression in Common Expression Language syntax.
	Expression *string `pulumi:"expression"`
	// Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file.
	Location *string `pulumi:"location"`
	// Optional. Title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.
	Title *string `pulumi:"title"`
}

Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expression language. The syntax and semantics of CEL are documented at https://github.com/google/cel-spec. Example (Comparison): title: "Summary size limit" description: "Determines if a summary is less than 100 chars" expression: "document.summary.size() < 100" Example (Equality): title: "Requestor is owner" description: "Determines if requestor is the document owner" expression: "document.owner == request.auth.claims.email" Example (Logic): title: "Public documents" description: "Determine whether the document should be publicly visible" expression: "document.type != 'private' && document.type != 'internal'" Example (Data Manipulation): title: "Notification string" description: "Create a notification string with a timestamp." expression: "'New message received at ' + string(document.create_time)" The exact variables and functions that may be referenced within an expression are determined by the service that evaluates it. See the service documentation for additional information.

type ExprArgs 

type ExprArgs struct {
	// Optional. Description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
	Description pulumi.StringPtrInput `pulumi:"description"`
	// Textual representation of an expression in Common Expression Language syntax.
	Expression pulumi.StringPtrInput `pulumi:"expression"`
	// Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file.
	Location pulumi.StringPtrInput `pulumi:"location"`
	// Optional. Title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.
	Title pulumi.StringPtrInput `pulumi:"title"`
}

Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expression language. The syntax and semantics of CEL are documented at https://github.com/google/cel-spec. Example (Comparison): title: "Summary size limit" description: "Determines if a summary is less than 100 chars" expression: "document.summary.size() < 100" Example (Equality): title: "Requestor is owner" description: "Determines if requestor is the document owner" expression: "document.owner == request.auth.claims.email" Example (Logic): title: "Public documents" description: "Determine whether the document should be publicly visible" expression: "document.type != 'private' && document.type != 'internal'" Example (Data Manipulation): title: "Notification string" description: "Create a notification string with a timestamp." expression: "'New message received at ' + string(document.create_time)" The exact variables and functions that may be referenced within an expression are determined by the service that evaluates it. See the service documentation for additional information.

func (ExprArgs) ElementType 

func (ExprArgs) ElementType() reflect.Type

func (ExprArgs) ToExprOutput 

func (i ExprArgs) ToExprOutput() ExprOutput

func (ExprArgs) ToExprOutputWithContext 

func (i ExprArgs) ToExprOutputWithContext(ctx context.Context) ExprOutput

func (ExprArgs) ToExprPtrOutput 

func (i ExprArgs) ToExprPtrOutput() ExprPtrOutput

func (ExprArgs) ToExprPtrOutputWithContext 

func (i ExprArgs) ToExprPtrOutputWithContext(ctx context.Context) ExprPtrOutput

type ExprInput 

type ExprInput interface {
	pulumi.Input

	ToExprOutput() ExprOutput
	ToExprOutputWithContext(context.Context) ExprOutput
}

ExprInput is an input type that accepts ExprArgs and ExprOutput values. You can construct a concrete instance of `ExprInput` via: 

ExprArgs{...}

type ExprOutput 

type ExprOutput struct{ *pulumi.OutputState }

Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expression language. The syntax and semantics of CEL are documented at https://github.com/google/cel-spec. Example (Comparison): title: "Summary size limit" description: "Determines if a summary is less than 100 chars" expression: "document.summary.size() < 100" Example (Equality): title: "Requestor is owner" description: "Determines if requestor is the document owner" expression: "document.owner == request.auth.claims.email" Example (Logic): title: "Public documents" description: "Determine whether the document should be publicly visible" expression: "document.type != 'private' && document.type != 'internal'" Example (Data Manipulation): title: "Notification string" description: "Create a notification string with a timestamp." expression: "'New message received at ' + string(document.create_time)" The exact variables and functions that may be referenced within an expression are determined by the service that evaluates it. See the service documentation for additional information.

func (ExprOutput) Description 

func (o ExprOutput) Description() pulumi.StringPtrOutput

Optional. Description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.

func (ExprOutput) ElementType 

func (ExprOutput) ElementType() reflect.Type

func (ExprOutput) Expression 

func (o ExprOutput) Expression() pulumi.StringPtrOutput

Textual representation of an expression in Common Expression Language syntax.

func (ExprOutput) Location 

func (o ExprOutput) Location() pulumi.StringPtrOutput

Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file.

func (ExprOutput) Title 

func (o ExprOutput) Title() pulumi.StringPtrOutput

Optional. Title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.

func (ExprOutput) ToExprOutput 

func (o ExprOutput) ToExprOutput() ExprOutput

func (ExprOutput) ToExprOutputWithContext 

func (o ExprOutput) ToExprOutputWithContext(ctx context.Context) ExprOutput

func (ExprOutput) ToExprPtrOutput 

func (o ExprOutput) ToExprPtrOutput() ExprPtrOutput

func (ExprOutput) ToExprPtrOutputWithContext 

func (o ExprOutput) ToExprPtrOutputWithContext(ctx context.Context) ExprPtrOutput

type ExprPtrInput 

type ExprPtrInput interface {
	pulumi.Input

	ToExprPtrOutput() ExprPtrOutput
	ToExprPtrOutputWithContext(context.Context) ExprPtrOutput
}

ExprPtrInput is an input type that accepts ExprArgs, ExprPtr and ExprPtrOutput values. You can construct a concrete instance of `ExprPtrInput` via: 

        ExprArgs{...}

or:

        nil

func ExprPtr 

func ExprPtr(v *ExprArgs) ExprPtrInput

type ExprPtrOutput 

type ExprPtrOutput struct{ *pulumi.OutputState }

func (ExprPtrOutput) Description 

func (o ExprPtrOutput) Description() pulumi.StringPtrOutput

Optional. Description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.

func (ExprPtrOutput) Elem 

func (o ExprPtrOutput) Elem() ExprOutput

func (ExprPtrOutput) ElementType 

func (ExprPtrOutput) ElementType() reflect.Type

func (ExprPtrOutput) Expression 

func (o ExprPtrOutput) Expression() pulumi.StringPtrOutput

Textual representation of an expression in Common Expression Language syntax.

func (ExprPtrOutput) Location 

func (o ExprPtrOutput) Location() pulumi.StringPtrOutput

Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file.

func (ExprPtrOutput) Title 

func (o ExprPtrOutput) Title() pulumi.StringPtrOutput

Optional. Title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.

func (ExprPtrOutput) ToExprPtrOutput 

func (o ExprPtrOutput) ToExprPtrOutput() ExprPtrOutput

func (ExprPtrOutput) ToExprPtrOutputWithContext 

func (o ExprPtrOutput) ToExprPtrOutputWithContext(ctx context.Context) ExprPtrOutput

type ExprResponse 

type ExprResponse struct {
	// Optional. Description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
	Description string `pulumi:"description"`
	// Textual representation of an expression in Common Expression Language syntax.
	Expression string `pulumi:"expression"`
	// Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file.
	Location string `pulumi:"location"`
	// Optional. Title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.
	Title string `pulumi:"title"`
}

Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expression language. The syntax and semantics of CEL are documented at https://github.com/google/cel-spec. Example (Comparison): title: "Summary size limit" description: "Determines if a summary is less than 100 chars" expression: "document.summary.size() < 100" Example (Equality): title: "Requestor is owner" description: "Determines if requestor is the document owner" expression: "document.owner == request.auth.claims.email" Example (Logic): title: "Public documents" description: "Determine whether the document should be publicly visible" expression: "document.type != 'private' && document.type != 'internal'" Example (Data Manipulation): title: "Notification string" description: "Create a notification string with a timestamp." expression: "'New message received at ' + string(document.create_time)" The exact variables and functions that may be referenced within an expression are determined by the service that evaluates it. See the service documentation for additional information.

type ExprResponseArgs 

type ExprResponseArgs struct {
	// Optional. Description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.
	Description pulumi.StringInput `pulumi:"description"`
	// Textual representation of an expression in Common Expression Language syntax.
	Expression pulumi.StringInput `pulumi:"expression"`
	// Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file.
	Location pulumi.StringInput `pulumi:"location"`
	// Optional. Title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.
	Title pulumi.StringInput `pulumi:"title"`
}

Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expression language. The syntax and semantics of CEL are documented at https://github.com/google/cel-spec. Example (Comparison): title: "Summary size limit" description: "Determines if a summary is less than 100 chars" expression: "document.summary.size() < 100" Example (Equality): title: "Requestor is owner" description: "Determines if requestor is the document owner" expression: "document.owner == request.auth.claims.email" Example (Logic): title: "Public documents" description: "Determine whether the document should be publicly visible" expression: "document.type != 'private' && document.type != 'internal'" Example (Data Manipulation): title: "Notification string" description: "Create a notification string with a timestamp." expression: "'New message received at ' + string(document.create_time)" The exact variables and functions that may be referenced within an expression are determined by the service that evaluates it. See the service documentation for additional information.

func (ExprResponseArgs) ElementType 

func (ExprResponseArgs) ElementType() reflect.Type

func (ExprResponseArgs) ToExprResponseOutput 

func (i ExprResponseArgs) ToExprResponseOutput() ExprResponseOutput

func (ExprResponseArgs) ToExprResponseOutputWithContext 

func (i ExprResponseArgs) ToExprResponseOutputWithContext(ctx context.Context) ExprResponseOutput

type ExprResponseInput 

type ExprResponseInput interface {
	pulumi.Input

	ToExprResponseOutput() ExprResponseOutput
	ToExprResponseOutputWithContext(context.Context) ExprResponseOutput
}

ExprResponseInput is an input type that accepts ExprResponseArgs and ExprResponseOutput values. You can construct a concrete instance of `ExprResponseInput` via: 

ExprResponseArgs{...}

type ExprResponseOutput 

type ExprResponseOutput struct{ *pulumi.OutputState }

Represents a textual expression in the Common Expression Language (CEL) syntax. CEL is a C-like expression language. The syntax and semantics of CEL are documented at https://github.com/google/cel-spec. Example (Comparison): title: "Summary size limit" description: "Determines if a summary is less than 100 chars" expression: "document.summary.size() < 100" Example (Equality): title: "Requestor is owner" description: "Determines if requestor is the document owner" expression: "document.owner == request.auth.claims.email" Example (Logic): title: "Public documents" description: "Determine whether the document should be publicly visible" expression: "document.type != 'private' && document.type != 'internal'" Example (Data Manipulation): title: "Notification string" description: "Create a notification string with a timestamp." expression: "'New message received at ' + string(document.create_time)" The exact variables and functions that may be referenced within an expression are determined by the service that evaluates it. See the service documentation for additional information.

func (ExprResponseOutput) Description 

func (o ExprResponseOutput) Description() pulumi.StringOutput

Optional. Description of the expression. This is a longer text which describes the expression, e.g. when hovered over it in a UI.

func (ExprResponseOutput) ElementType 

func (ExprResponseOutput) ElementType() reflect.Type

func (ExprResponseOutput) Expression 

func (o ExprResponseOutput) Expression() pulumi.StringOutput

Textual representation of an expression in Common Expression Language syntax.

func (ExprResponseOutput) Location 

func (o ExprResponseOutput) Location() pulumi.StringOutput

Optional. String indicating the location of the expression for error reporting, e.g. a file name and a position in the file.

func (ExprResponseOutput) Title 

func (o ExprResponseOutput) Title() pulumi.StringOutput

Optional. Title for the expression, i.e. a short string describing its purpose. This can be used e.g. in UIs which allow to enter the expression.

func (ExprResponseOutput) ToExprResponseOutput 

func (o ExprResponseOutput) ToExprResponseOutput() ExprResponseOutput

func (ExprResponseOutput) ToExprResponseOutputWithContext 

func (o ExprResponseOutput) ToExprResponseOutputWithContext(ctx context.Context) ExprResponseOutput

type FleetConfig 

type FleetConfig struct {
	// Agones fleet spec. Example spec: `https://agones.dev/site/docs/reference/fleet/`.
	FleetSpec *string `pulumi:"fleetSpec"`
	// The name of the FleetConfig.
	Name *string `pulumi:"name"`
}

Fleet configs for Agones.

type FleetConfigArgs 

type FleetConfigArgs struct {
	// Agones fleet spec. Example spec: `https://agones.dev/site/docs/reference/fleet/`.
	FleetSpec pulumi.StringPtrInput `pulumi:"fleetSpec"`
	// The name of the FleetConfig.
	Name pulumi.StringPtrInput `pulumi:"name"`
}

Fleet configs for Agones.

func (FleetConfigArgs) ElementType 

func (FleetConfigArgs) ElementType() reflect.Type

func (FleetConfigArgs) ToFleetConfigOutput 

func (i FleetConfigArgs) ToFleetConfigOutput() FleetConfigOutput

func (FleetConfigArgs) ToFleetConfigOutputWithContext 

func (i FleetConfigArgs) ToFleetConfigOutputWithContext(ctx context.Context) FleetConfigOutput

type FleetConfigArray 

type FleetConfigArray []FleetConfigInput

func (FleetConfigArray) ElementType 

func (FleetConfigArray) ElementType() reflect.Type

func (FleetConfigArray) ToFleetConfigArrayOutput 

func (i FleetConfigArray) ToFleetConfigArrayOutput() FleetConfigArrayOutput

func (FleetConfigArray) ToFleetConfigArrayOutputWithContext 

func (i FleetConfigArray) ToFleetConfigArrayOutputWithContext(ctx context.Context) FleetConfigArrayOutput

type FleetConfigArrayInput 

type FleetConfigArrayInput interface {
	pulumi.Input

	ToFleetConfigArrayOutput() FleetConfigArrayOutput
	ToFleetConfigArrayOutputWithContext(context.Context) FleetConfigArrayOutput
}

FleetConfigArrayInput is an input type that accepts FleetConfigArray and FleetConfigArrayOutput values. You can construct a concrete instance of `FleetConfigArrayInput` via: 

FleetConfigArray{ FleetConfigArgs{...} }

type FleetConfigArrayOutput 

type FleetConfigArrayOutput struct{ *pulumi.OutputState }

func (FleetConfigArrayOutput) ElementType 

func (FleetConfigArrayOutput) ElementType() reflect.Type

func (FleetConfigArrayOutput) Index 

func (o FleetConfigArrayOutput) Index(i pulumi.IntInput) FleetConfigOutput

func (FleetConfigArrayOutput) ToFleetConfigArrayOutput 

func (o FleetConfigArrayOutput) ToFleetConfigArrayOutput() FleetConfigArrayOutput

func (FleetConfigArrayOutput) ToFleetConfigArrayOutputWithContext 

func (o FleetConfigArrayOutput) ToFleetConfigArrayOutputWithContext(ctx context.Context) FleetConfigArrayOutput

type FleetConfigInput 

type FleetConfigInput interface {
	pulumi.Input

	ToFleetConfigOutput() FleetConfigOutput
	ToFleetConfigOutputWithContext(context.Context) FleetConfigOutput
}

FleetConfigInput is an input type that accepts FleetConfigArgs and FleetConfigOutput values. You can construct a concrete instance of `FleetConfigInput` via: 

FleetConfigArgs{...}

type FleetConfigOutput 

type FleetConfigOutput struct{ *pulumi.OutputState }

Fleet configs for Agones.

func (FleetConfigOutput) ElementType 

func (FleetConfigOutput) ElementType() reflect.Type

func (FleetConfigOutput) FleetSpec 

func (o FleetConfigOutput) FleetSpec() pulumi.StringPtrOutput

Agones fleet spec. Example spec: `https://agones.dev/site/docs/reference/fleet/`.

func (FleetConfigOutput) Name 

func (o FleetConfigOutput) Name() pulumi.StringPtrOutput

The name of the FleetConfig.

func (FleetConfigOutput) ToFleetConfigOutput 

func (o FleetConfigOutput) ToFleetConfigOutput() FleetConfigOutput

func (FleetConfigOutput) ToFleetConfigOutputWithContext 

func (o FleetConfigOutput) ToFleetConfigOutputWithContext(ctx context.Context) FleetConfigOutput

type FleetConfigResponse 

type FleetConfigResponse struct {
	// Agones fleet spec. Example spec: `https://agones.dev/site/docs/reference/fleet/`.
	FleetSpec string `pulumi:"fleetSpec"`
	// The name of the FleetConfig.
	Name string `pulumi:"name"`
}

Fleet configs for Agones.

type FleetConfigResponseArgs 

type FleetConfigResponseArgs struct {
	// Agones fleet spec. Example spec: `https://agones.dev/site/docs/reference/fleet/`.
	FleetSpec pulumi.StringInput `pulumi:"fleetSpec"`
	// The name of the FleetConfig.
	Name pulumi.StringInput `pulumi:"name"`
}

Fleet configs for Agones.

func (FleetConfigResponseArgs) ElementType 

func (FleetConfigResponseArgs) ElementType() reflect.Type

func (FleetConfigResponseArgs) ToFleetConfigResponseOutput 

func (i FleetConfigResponseArgs) ToFleetConfigResponseOutput() FleetConfigResponseOutput

func (FleetConfigResponseArgs) ToFleetConfigResponseOutputWithContext 

func (i FleetConfigResponseArgs) ToFleetConfigResponseOutputWithContext(ctx context.Context) FleetConfigResponseOutput

type FleetConfigResponseArray 

type FleetConfigResponseArray []FleetConfigResponseInput

func (FleetConfigResponseArray) ElementType 

func (FleetConfigResponseArray) ElementType() reflect.Type

func (FleetConfigResponseArray) ToFleetConfigResponseArrayOutput 

func (i FleetConfigResponseArray) ToFleetConfigResponseArrayOutput() FleetConfigResponseArrayOutput

func (FleetConfigResponseArray) ToFleetConfigResponseArrayOutputWithContext 

func (i FleetConfigResponseArray) ToFleetConfigResponseArrayOutputWithContext(ctx context.Context) FleetConfigResponseArrayOutput

type FleetConfigResponseArrayInput 

type FleetConfigResponseArrayInput interface {
	pulumi.Input

	ToFleetConfigResponseArrayOutput() FleetConfigResponseArrayOutput
	ToFleetConfigResponseArrayOutputWithContext(context.Context) FleetConfigResponseArrayOutput
}

FleetConfigResponseArrayInput is an input type that accepts FleetConfigResponseArray and FleetConfigResponseArrayOutput values. You can construct a concrete instance of `FleetConfigResponseArrayInput` via: 

FleetConfigResponseArray{ FleetConfigResponseArgs{...} }

type FleetConfigResponseArrayOutput 

type FleetConfigResponseArrayOutput struct{ *pulumi.OutputState }

func (FleetConfigResponseArrayOutput) ElementType 

func (FleetConfigResponseArrayOutput) ElementType() reflect.Type

func (FleetConfigResponseArrayOutput) Index 

func (o FleetConfigResponseArrayOutput) Index(i pulumi.IntInput) FleetConfigResponseOutput

func (FleetConfigResponseArrayOutput) ToFleetConfigResponseArrayOutput 

func (o FleetConfigResponseArrayOutput) ToFleetConfigResponseArrayOutput() FleetConfigResponseArrayOutput

func (FleetConfigResponseArrayOutput) ToFleetConfigResponseArrayOutputWithContext 

func (o FleetConfigResponseArrayOutput) ToFleetConfigResponseArrayOutputWithContext(ctx context.Context) FleetConfigResponseArrayOutput

type FleetConfigResponseInput 

type FleetConfigResponseInput interface {
	pulumi.Input

	ToFleetConfigResponseOutput() FleetConfigResponseOutput
	ToFleetConfigResponseOutputWithContext(context.Context) FleetConfigResponseOutput
}

FleetConfigResponseInput is an input type that accepts FleetConfigResponseArgs and FleetConfigResponseOutput values. You can construct a concrete instance of `FleetConfigResponseInput` via: 

FleetConfigResponseArgs{...}

type FleetConfigResponseOutput 

type FleetConfigResponseOutput struct{ *pulumi.OutputState }

Fleet configs for Agones.

func (FleetConfigResponseOutput) ElementType 

func (FleetConfigResponseOutput) ElementType() reflect.Type

func (FleetConfigResponseOutput) FleetSpec 

func (o FleetConfigResponseOutput) FleetSpec() pulumi.StringOutput

Agones fleet spec. Example spec: `https://agones.dev/site/docs/reference/fleet/`.

func (FleetConfigResponseOutput) Name 

func (o FleetConfigResponseOutput) Name() pulumi.StringOutput

The name of the FleetConfig.

func (FleetConfigResponseOutput) ToFleetConfigResponseOutput 

func (o FleetConfigResponseOutput) ToFleetConfigResponseOutput() FleetConfigResponseOutput

func (FleetConfigResponseOutput) ToFleetConfigResponseOutputWithContext 

func (o FleetConfigResponseOutput) ToFleetConfigResponseOutputWithContext(ctx context.Context) FleetConfigResponseOutput

type GameServerCluster added in v0.3.0 

type GameServerCluster struct {
	pulumi.CustomResourceState

	// The game server cluster connection information. This information is used to manage game server clusters.
	ConnectionInfo GameServerClusterConnectionInfoResponseOutput `pulumi:"connectionInfo"`
	// The creation time.
	CreateTime pulumi.StringOutput `pulumi:"createTime"`
	// Human readable description of the cluster.
	Description pulumi.StringOutput `pulumi:"description"`
	// ETag of the resource.
	Etag pulumi.StringOutput `pulumi:"etag"`
	// The labels associated with this game server cluster. Each label is a key-value pair.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// Required. The resource name of the game server cluster, in the following form: `projects/{project}/locations/{location}/realms/{realm}/gameServerClusters/{cluster}`. For example, `projects/my-project/locations/{location}/realms/zanzibar/gameServerClusters/my-onprem-cluster`.
	Name pulumi.StringOutput `pulumi:"name"`
	// The last-modified time.
	UpdateTime pulumi.StringOutput `pulumi:"updateTime"`
}

Creates a new game server cluster in a given project and location.

func GetGameServerCluster added in v0.3.0 

func GetGameServerCluster(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *GameServerClusterState, opts ...pulumi.ResourceOption) (*GameServerCluster, error)

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

func NewGameServerCluster added in v0.3.0 

func NewGameServerCluster(ctx *pulumi.Context,
	name string, args *GameServerClusterArgs, opts ...pulumi.ResourceOption) (*GameServerCluster, error)

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

func (*GameServerCluster) ElementType added in v0.3.0 

func (*GameServerCluster) ElementType() reflect.Type

func (*GameServerCluster) ToGameServerClusterOutput added in v0.3.0 

func (i *GameServerCluster) ToGameServerClusterOutput() GameServerClusterOutput

func (*GameServerCluster) ToGameServerClusterOutputWithContext added in v0.3.0 

func (i *GameServerCluster) ToGameServerClusterOutputWithContext(ctx context.Context) GameServerClusterOutput

type GameServerClusterArgs added in v0.3.0 

type GameServerClusterArgs struct {
	// The game server cluster connection information. This information is used to manage game server clusters.
	ConnectionInfo GameServerClusterConnectionInfoPtrInput
	// Human readable description of the cluster.
	Description pulumi.StringPtrInput
	// ETag of the resource.
	Etag                pulumi.StringPtrInput
	GameServerClusterId pulumi.StringInput
	// The labels associated with this game server cluster. Each label is a key-value pair.
	Labels   pulumi.StringMapInput
	Location pulumi.StringInput
	// Required. The resource name of the game server cluster, in the following form: `projects/{project}/locations/{location}/realms/{realm}/gameServerClusters/{cluster}`. For example, `projects/my-project/locations/{location}/realms/zanzibar/gameServerClusters/my-onprem-cluster`.
	Name    pulumi.StringPtrInput
	Project pulumi.StringInput
	RealmId pulumi.StringInput
}

The set of arguments for constructing a GameServerCluster resource.

func (GameServerClusterArgs) ElementType added in v0.3.0 

func (GameServerClusterArgs) ElementType() reflect.Type

type GameServerClusterConnectionInfo 

type GameServerClusterConnectionInfo struct {
	// Reference to the GKE cluster where the game servers are installed.
	GkeClusterReference *GkeClusterReference `pulumi:"gkeClusterReference"`
	// Namespace designated on the game server cluster where the Agones game server instances will be created. Existence of the namespace will be validated during creation.
	Namespace *string `pulumi:"namespace"`
}

The game server cluster connection information.

type GameServerClusterConnectionInfoArgs 

type GameServerClusterConnectionInfoArgs struct {
	// Reference to the GKE cluster where the game servers are installed.
	GkeClusterReference GkeClusterReferencePtrInput `pulumi:"gkeClusterReference"`
	// Namespace designated on the game server cluster where the Agones game server instances will be created. Existence of the namespace will be validated during creation.
	Namespace pulumi.StringPtrInput `pulumi:"namespace"`
}

The game server cluster connection information.

func (GameServerClusterConnectionInfoArgs) ElementType 

func (GameServerClusterConnectionInfoArgs) ElementType() reflect.Type

func (GameServerClusterConnectionInfoArgs) ToGameServerClusterConnectionInfoOutput 

func (i GameServerClusterConnectionInfoArgs) ToGameServerClusterConnectionInfoOutput() GameServerClusterConnectionInfoOutput

func (GameServerClusterConnectionInfoArgs) ToGameServerClusterConnectionInfoOutputWithContext 

func (i GameServerClusterConnectionInfoArgs) ToGameServerClusterConnectionInfoOutputWithContext(ctx context.Context) GameServerClusterConnectionInfoOutput

func (GameServerClusterConnectionInfoArgs) ToGameServerClusterConnectionInfoPtrOutput 

func (i GameServerClusterConnectionInfoArgs) ToGameServerClusterConnectionInfoPtrOutput() GameServerClusterConnectionInfoPtrOutput

func (GameServerClusterConnectionInfoArgs) ToGameServerClusterConnectionInfoPtrOutputWithContext 

func (i GameServerClusterConnectionInfoArgs) ToGameServerClusterConnectionInfoPtrOutputWithContext(ctx context.Context) GameServerClusterConnectionInfoPtrOutput

type GameServerClusterConnectionInfoInput 

type GameServerClusterConnectionInfoInput interface {
	pulumi.Input

	ToGameServerClusterConnectionInfoOutput() GameServerClusterConnectionInfoOutput
	ToGameServerClusterConnectionInfoOutputWithContext(context.Context) GameServerClusterConnectionInfoOutput
}

GameServerClusterConnectionInfoInput is an input type that accepts GameServerClusterConnectionInfoArgs and GameServerClusterConnectionInfoOutput values. You can construct a concrete instance of `GameServerClusterConnectionInfoInput` via: 

GameServerClusterConnectionInfoArgs{...}

type GameServerClusterConnectionInfoOutput 

type GameServerClusterConnectionInfoOutput struct{ *pulumi.OutputState }

The game server cluster connection information.

func (GameServerClusterConnectionInfoOutput) ElementType 

func (GameServerClusterConnectionInfoOutput) ElementType() reflect.Type

func (GameServerClusterConnectionInfoOutput) GkeClusterReference 

func (o GameServerClusterConnectionInfoOutput) GkeClusterReference() GkeClusterReferencePtrOutput

Reference to the GKE cluster where the game servers are installed.

func (GameServerClusterConnectionInfoOutput) Namespace 

func (o GameServerClusterConnectionInfoOutput) Namespace() pulumi.StringPtrOutput

Namespace designated on the game server cluster where the Agones game server instances will be created. Existence of the namespace will be validated during creation.

func (GameServerClusterConnectionInfoOutput) ToGameServerClusterConnectionInfoOutput 

func (o GameServerClusterConnectionInfoOutput) ToGameServerClusterConnectionInfoOutput() GameServerClusterConnectionInfoOutput

func (GameServerClusterConnectionInfoOutput) ToGameServerClusterConnectionInfoOutputWithContext 

func (o GameServerClusterConnectionInfoOutput) ToGameServerClusterConnectionInfoOutputWithContext(ctx context.Context) GameServerClusterConnectionInfoOutput

func (GameServerClusterConnectionInfoOutput) ToGameServerClusterConnectionInfoPtrOutput 

func (o GameServerClusterConnectionInfoOutput) ToGameServerClusterConnectionInfoPtrOutput() GameServerClusterConnectionInfoPtrOutput

func (GameServerClusterConnectionInfoOutput) ToGameServerClusterConnectionInfoPtrOutputWithContext 

func (o GameServerClusterConnectionInfoOutput) ToGameServerClusterConnectionInfoPtrOutputWithContext(ctx context.Context) GameServerClusterConnectionInfoPtrOutput

type GameServerClusterConnectionInfoPtrInput 

type GameServerClusterConnectionInfoPtrInput interface {
	pulumi.Input

	ToGameServerClusterConnectionInfoPtrOutput() GameServerClusterConnectionInfoPtrOutput
	ToGameServerClusterConnectionInfoPtrOutputWithContext(context.Context) GameServerClusterConnectionInfoPtrOutput
}

GameServerClusterConnectionInfoPtrInput is an input type that accepts GameServerClusterConnectionInfoArgs, GameServerClusterConnectionInfoPtr and GameServerClusterConnectionInfoPtrOutput values. You can construct a concrete instance of `GameServerClusterConnectionInfoPtrInput` via: 

        GameServerClusterConnectionInfoArgs{...}

or:

        nil

func GameServerClusterConnectionInfoPtr 

func GameServerClusterConnectionInfoPtr(v *GameServerClusterConnectionInfoArgs) GameServerClusterConnectionInfoPtrInput

type GameServerClusterConnectionInfoPtrOutput 

type GameServerClusterConnectionInfoPtrOutput struct{ *pulumi.OutputState }

func (GameServerClusterConnectionInfoPtrOutput) Elem 

func (o GameServerClusterConnectionInfoPtrOutput) Elem() GameServerClusterConnectionInfoOutput

func (GameServerClusterConnectionInfoPtrOutput) ElementType 

func (GameServerClusterConnectionInfoPtrOutput) ElementType() reflect.Type

func (GameServerClusterConnectionInfoPtrOutput) GkeClusterReference 

func (o GameServerClusterConnectionInfoPtrOutput) GkeClusterReference() GkeClusterReferencePtrOutput

Reference to the GKE cluster where the game servers are installed.

func (GameServerClusterConnectionInfoPtrOutput) Namespace 

func (o GameServerClusterConnectionInfoPtrOutput) Namespace() pulumi.StringPtrOutput

Namespace designated on the game server cluster where the Agones game server instances will be created. Existence of the namespace will be validated during creation.

func (GameServerClusterConnectionInfoPtrOutput) ToGameServerClusterConnectionInfoPtrOutput 

func (o GameServerClusterConnectionInfoPtrOutput) ToGameServerClusterConnectionInfoPtrOutput() GameServerClusterConnectionInfoPtrOutput

func (GameServerClusterConnectionInfoPtrOutput) ToGameServerClusterConnectionInfoPtrOutputWithContext 

func (o GameServerClusterConnectionInfoPtrOutput) ToGameServerClusterConnectionInfoPtrOutputWithContext(ctx context.Context) GameServerClusterConnectionInfoPtrOutput

type GameServerClusterConnectionInfoResponse 

type GameServerClusterConnectionInfoResponse struct {
	// Reference to the GKE cluster where the game servers are installed.
	GkeClusterReference GkeClusterReferenceResponse `pulumi:"gkeClusterReference"`
	// Namespace designated on the game server cluster where the Agones game server instances will be created. Existence of the namespace will be validated during creation.
	Namespace string `pulumi:"namespace"`
}

The game server cluster connection information.

type GameServerClusterConnectionInfoResponseArgs 

type GameServerClusterConnectionInfoResponseArgs struct {
	// Reference to the GKE cluster where the game servers are installed.
	GkeClusterReference GkeClusterReferenceResponseInput `pulumi:"gkeClusterReference"`
	// Namespace designated on the game server cluster where the Agones game server instances will be created. Existence of the namespace will be validated during creation.
	Namespace pulumi.StringInput `pulumi:"namespace"`
}

The game server cluster connection information.

func (GameServerClusterConnectionInfoResponseArgs) ElementType 

func (GameServerClusterConnectionInfoResponseArgs) ElementType() reflect.Type

func (GameServerClusterConnectionInfoResponseArgs) ToGameServerClusterConnectionInfoResponseOutput 

func (i GameServerClusterConnectionInfoResponseArgs) ToGameServerClusterConnectionInfoResponseOutput() GameServerClusterConnectionInfoResponseOutput

func (GameServerClusterConnectionInfoResponseArgs) ToGameServerClusterConnectionInfoResponseOutputWithContext 

func (i GameServerClusterConnectionInfoResponseArgs) ToGameServerClusterConnectionInfoResponseOutputWithContext(ctx context.Context) GameServerClusterConnectionInfoResponseOutput

func (GameServerClusterConnectionInfoResponseArgs) ToGameServerClusterConnectionInfoResponsePtrOutput 

func (i GameServerClusterConnectionInfoResponseArgs) ToGameServerClusterConnectionInfoResponsePtrOutput() GameServerClusterConnectionInfoResponsePtrOutput

func (GameServerClusterConnectionInfoResponseArgs) ToGameServerClusterConnectionInfoResponsePtrOutputWithContext 

func (i GameServerClusterConnectionInfoResponseArgs) ToGameServerClusterConnectionInfoResponsePtrOutputWithContext(ctx context.Context) GameServerClusterConnectionInfoResponsePtrOutput

type GameServerClusterConnectionInfoResponseInput 

type GameServerClusterConnectionInfoResponseInput interface {
	pulumi.Input

	ToGameServerClusterConnectionInfoResponseOutput() GameServerClusterConnectionInfoResponseOutput
	ToGameServerClusterConnectionInfoResponseOutputWithContext(context.Context) GameServerClusterConnectionInfoResponseOutput
}

GameServerClusterConnectionInfoResponseInput is an input type that accepts GameServerClusterConnectionInfoResponseArgs and GameServerClusterConnectionInfoResponseOutput values. You can construct a concrete instance of `GameServerClusterConnectionInfoResponseInput` via: 

GameServerClusterConnectionInfoResponseArgs{...}

type GameServerClusterConnectionInfoResponseOutput 

type GameServerClusterConnectionInfoResponseOutput struct{ *pulumi.OutputState }

The game server cluster connection information.

func (GameServerClusterConnectionInfoResponseOutput) ElementType 

func (GameServerClusterConnectionInfoResponseOutput) ElementType() reflect.Type

func (GameServerClusterConnectionInfoResponseOutput) GkeClusterReference 

func (o GameServerClusterConnectionInfoResponseOutput) GkeClusterReference() GkeClusterReferenceResponseOutput

Reference to the GKE cluster where the game servers are installed.

func (GameServerClusterConnectionInfoResponseOutput) Namespace 

func (o GameServerClusterConnectionInfoResponseOutput) Namespace() pulumi.StringOutput

Namespace designated on the game server cluster where the Agones game server instances will be created. Existence of the namespace will be validated during creation.

func (GameServerClusterConnectionInfoResponseOutput) ToGameServerClusterConnectionInfoResponseOutput 

func (o GameServerClusterConnectionInfoResponseOutput) ToGameServerClusterConnectionInfoResponseOutput() GameServerClusterConnectionInfoResponseOutput

func (GameServerClusterConnectionInfoResponseOutput) ToGameServerClusterConnectionInfoResponseOutputWithContext 

func (o GameServerClusterConnectionInfoResponseOutput) ToGameServerClusterConnectionInfoResponseOutputWithContext(ctx context.Context) GameServerClusterConnectionInfoResponseOutput

func (GameServerClusterConnectionInfoResponseOutput) ToGameServerClusterConnectionInfoResponsePtrOutput 

func (o GameServerClusterConnectionInfoResponseOutput) ToGameServerClusterConnectionInfoResponsePtrOutput() GameServerClusterConnectionInfoResponsePtrOutput

func (GameServerClusterConnectionInfoResponseOutput) ToGameServerClusterConnectionInfoResponsePtrOutputWithContext 

func (o GameServerClusterConnectionInfoResponseOutput) ToGameServerClusterConnectionInfoResponsePtrOutputWithContext(ctx context.Context) GameServerClusterConnectionInfoResponsePtrOutput

type GameServerClusterConnectionInfoResponsePtrInput 

type GameServerClusterConnectionInfoResponsePtrInput interface {
	pulumi.Input

	ToGameServerClusterConnectionInfoResponsePtrOutput() GameServerClusterConnectionInfoResponsePtrOutput
	ToGameServerClusterConnectionInfoResponsePtrOutputWithContext(context.Context) GameServerClusterConnectionInfoResponsePtrOutput
}

GameServerClusterConnectionInfoResponsePtrInput is an input type that accepts GameServerClusterConnectionInfoResponseArgs, GameServerClusterConnectionInfoResponsePtr and GameServerClusterConnectionInfoResponsePtrOutput values. You can construct a concrete instance of `GameServerClusterConnectionInfoResponsePtrInput` via: 

        GameServerClusterConnectionInfoResponseArgs{...}

or:

        nil

func GameServerClusterConnectionInfoResponsePtr 

func GameServerClusterConnectionInfoResponsePtr(v *GameServerClusterConnectionInfoResponseArgs) GameServerClusterConnectionInfoResponsePtrInput

type GameServerClusterConnectionInfoResponsePtrOutput 

type GameServerClusterConnectionInfoResponsePtrOutput struct{ *pulumi.OutputState }

func (GameServerClusterConnectionInfoResponsePtrOutput) Elem 

func (o GameServerClusterConnectionInfoResponsePtrOutput) Elem() GameServerClusterConnectionInfoResponseOutput

func (GameServerClusterConnectionInfoResponsePtrOutput) ElementType 

func (GameServerClusterConnectionInfoResponsePtrOutput) ElementType() reflect.Type

func (GameServerClusterConnectionInfoResponsePtrOutput) GkeClusterReference 

func (o GameServerClusterConnectionInfoResponsePtrOutput) GkeClusterReference() GkeClusterReferenceResponsePtrOutput

Reference to the GKE cluster where the game servers are installed.

func (GameServerClusterConnectionInfoResponsePtrOutput) Namespace 

func (o GameServerClusterConnectionInfoResponsePtrOutput) Namespace() pulumi.StringPtrOutput

Namespace designated on the game server cluster where the Agones game server instances will be created. Existence of the namespace will be validated during creation.

func (GameServerClusterConnectionInfoResponsePtrOutput) ToGameServerClusterConnectionInfoResponsePtrOutput 

func (o GameServerClusterConnectionInfoResponsePtrOutput) ToGameServerClusterConnectionInfoResponsePtrOutput() GameServerClusterConnectionInfoResponsePtrOutput

func (GameServerClusterConnectionInfoResponsePtrOutput) ToGameServerClusterConnectionInfoResponsePtrOutputWithContext 

func (o GameServerClusterConnectionInfoResponsePtrOutput) ToGameServerClusterConnectionInfoResponsePtrOutputWithContext(ctx context.Context) GameServerClusterConnectionInfoResponsePtrOutput

type GameServerClusterInput added in v0.3.0 

type GameServerClusterInput interface {
	pulumi.Input

	ToGameServerClusterOutput() GameServerClusterOutput
	ToGameServerClusterOutputWithContext(ctx context.Context) GameServerClusterOutput
}

type GameServerClusterOutput added in v0.3.0 

type GameServerClusterOutput struct {
	*pulumi.OutputState
}

func (GameServerClusterOutput) ElementType added in v0.3.0 

func (GameServerClusterOutput) ElementType() reflect.Type

func (GameServerClusterOutput) ToGameServerClusterOutput added in v0.3.0 

func (o GameServerClusterOutput) ToGameServerClusterOutput() GameServerClusterOutput

func (GameServerClusterOutput) ToGameServerClusterOutputWithContext added in v0.3.0 

func (o GameServerClusterOutput) ToGameServerClusterOutputWithContext(ctx context.Context) GameServerClusterOutput

type GameServerClusterState added in v0.3.0 

type GameServerClusterState struct {
	// The game server cluster connection information. This information is used to manage game server clusters.
	ConnectionInfo GameServerClusterConnectionInfoResponsePtrInput
	// The creation time.
	CreateTime pulumi.StringPtrInput
	// Human readable description of the cluster.
	Description pulumi.StringPtrInput
	// ETag of the resource.
	Etag pulumi.StringPtrInput
	// The labels associated with this game server cluster. Each label is a key-value pair.
	Labels pulumi.StringMapInput
	// Required. The resource name of the game server cluster, in the following form: `projects/{project}/locations/{location}/realms/{realm}/gameServerClusters/{cluster}`. For example, `projects/my-project/locations/{location}/realms/zanzibar/gameServerClusters/my-onprem-cluster`.
	Name pulumi.StringPtrInput
	// The last-modified time.
	UpdateTime pulumi.StringPtrInput
}

func (GameServerClusterState) ElementType added in v0.3.0 

func (GameServerClusterState) ElementType() reflect.Type

type GameServerDeployment 

type GameServerDeployment struct {
	pulumi.CustomResourceState

	// The creation time.
	CreateTime pulumi.StringOutput `pulumi:"createTime"`
	// Human readable description of the game server delpoyment.
	Description pulumi.StringOutput `pulumi:"description"`
	// ETag of the resource.
	Etag pulumi.StringOutput `pulumi:"etag"`
	// The labels associated with this game server deployment. Each label is a key-value pair.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// The resource name of the game server deployment, in the following form: `projects/{project}/locations/{location}/gameServerDeployments/{deployment}`. For example, `projects/my-project/locations/global/gameServerDeployments/my-deployment`.
	Name pulumi.StringOutput `pulumi:"name"`
	// The last-modified time.
	UpdateTime pulumi.StringOutput `pulumi:"updateTime"`
}

Creates a new game server deployment in a given project and location.

func GetGameServerDeployment 

func GetGameServerDeployment(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *GameServerDeploymentState, opts ...pulumi.ResourceOption) (*GameServerDeployment, error)

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

func NewGameServerDeployment 

func NewGameServerDeployment(ctx *pulumi.Context,
	name string, args *GameServerDeploymentArgs, opts ...pulumi.ResourceOption) (*GameServerDeployment, error)

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

func (*GameServerDeployment) ElementType 

func (*GameServerDeployment) ElementType() reflect.Type

func (*GameServerDeployment) ToGameServerDeploymentOutput 

func (i *GameServerDeployment) ToGameServerDeploymentOutput() GameServerDeploymentOutput

func (*GameServerDeployment) ToGameServerDeploymentOutputWithContext 

func (i *GameServerDeployment) ToGameServerDeploymentOutputWithContext(ctx context.Context) GameServerDeploymentOutput

type GameServerDeploymentArgs 

type GameServerDeploymentArgs struct {
	DeploymentId pulumi.StringInput
	// Human readable description of the game server delpoyment.
	Description pulumi.StringPtrInput
	// ETag of the resource.
	Etag pulumi.StringPtrInput
	// The labels associated with this game server deployment. Each label is a key-value pair.
	Labels   pulumi.StringMapInput
	Location pulumi.StringInput
	// The resource name of the game server deployment, in the following form: `projects/{project}/locations/{location}/gameServerDeployments/{deployment}`. For example, `projects/my-project/locations/global/gameServerDeployments/my-deployment`.
	Name    pulumi.StringPtrInput
	Project pulumi.StringInput
}

The set of arguments for constructing a GameServerDeployment resource.

func (GameServerDeploymentArgs) ElementType 

func (GameServerDeploymentArgs) ElementType() reflect.Type

type GameServerDeploymentIamPolicy 

type GameServerDeploymentIamPolicy struct {
	pulumi.CustomResourceState

	// Specifies cloud audit logging configuration for this policy.
	AuditConfigs AuditConfigResponseArrayOutput `pulumi:"auditConfigs"`
	// Associates a list of `members` to a `role`. Optionally, may specify a `condition` that determines how and when the `bindings` are applied. Each of the `bindings` must contain at least one member.
	Bindings BindingResponseArrayOutput `pulumi:"bindings"`
	// `etag` is used for optimistic concurrency control as a way to help prevent simultaneous updates of a policy from overwriting each other. It is strongly suggested that systems make use of the `etag` in the read-modify-write cycle to perform policy updates in order to avoid race conditions: An `etag` is returned in the response to `getIamPolicy`, and systems are expected to put that etag in the request to `setIamPolicy` to ensure that their change will be applied to the same version of the policy. **Important:** If you use IAM Conditions, you must include the `etag` field whenever you call `setIamPolicy`. If you omit this field, then IAM allows you to overwrite a version `3` policy with a version `1` policy, and all of the conditions in the version `3` policy are lost.
	Etag     pulumi.StringOutput `pulumi:"etag"`
	IamOwned pulumi.BoolOutput   `pulumi:"iamOwned"`
	// If more than one rule is specified, the rules are applied in the following manner: - All matching LOG rules are always applied. - If any DENY/DENY_WITH_LOG rule matches, permission is denied. Logging will be applied if one or more matching rule requires logging. - Otherwise, if any ALLOW/ALLOW_WITH_LOG rule matches, permission is granted. Logging will be applied if one or more matching rule requires logging. - Otherwise, if no rule applies, permission is denied.
	Rules RuleResponseArrayOutput `pulumi:"rules"`
	// Specifies the format of the policy. Valid values are `0`, `1`, and `3`. Requests that specify an invalid value are rejected. Any operation that affects conditional role bindings must specify version `3`. This requirement applies to the following operations: * Getting a policy that includes a conditional role binding * Adding a conditional role binding to a policy * Changing a conditional role binding in a policy * Removing any role binding, with or without a condition, from a policy that includes conditions **Important:** If you use IAM Conditions, you must include the `etag` field whenever you call `setIamPolicy`. If you omit this field, then IAM allows you to overwrite a version `3` policy with a version `1` policy, and all of the conditions in the version `3` policy are lost. If a policy does not include any conditions, operations on that policy may specify any valid version or leave the field unset. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
	Version pulumi.IntOutput `pulumi:"version"`
}

Sets the access control policy on the specified resource. Replaces any existing policy. Can return `NOT_FOUND`, `INVALID_ARGUMENT`, and `PERMISSION_DENIED` errors.

func GetGameServerDeploymentIamPolicy 

func GetGameServerDeploymentIamPolicy(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *GameServerDeploymentIamPolicyState, opts ...pulumi.ResourceOption) (*GameServerDeploymentIamPolicy, error)

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

func NewGameServerDeploymentIamPolicy 

func NewGameServerDeploymentIamPolicy(ctx *pulumi.Context,
	name string, args *GameServerDeploymentIamPolicyArgs, opts ...pulumi.ResourceOption) (*GameServerDeploymentIamPolicy, error)

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

func (*GameServerDeploymentIamPolicy) ElementType 

func (*GameServerDeploymentIamPolicy) ElementType() reflect.Type

func (*GameServerDeploymentIamPolicy) ToGameServerDeploymentIamPolicyOutput 

func (i *GameServerDeploymentIamPolicy) ToGameServerDeploymentIamPolicyOutput() GameServerDeploymentIamPolicyOutput

func (*GameServerDeploymentIamPolicy) ToGameServerDeploymentIamPolicyOutputWithContext 

func (i *GameServerDeploymentIamPolicy) ToGameServerDeploymentIamPolicyOutputWithContext(ctx context.Context) GameServerDeploymentIamPolicyOutput

type GameServerDeploymentIamPolicyArgs 

type GameServerDeploymentIamPolicyArgs struct {
	// Specifies cloud audit logging configuration for this policy.
	AuditConfigs AuditConfigArrayInput
	// Associates a list of `members` to a `role`. Optionally, may specify a `condition` that determines how and when the `bindings` are applied. Each of the `bindings` must contain at least one member.
	Bindings BindingArrayInput
	// `etag` is used for optimistic concurrency control as a way to help prevent simultaneous updates of a policy from overwriting each other. It is strongly suggested that systems make use of the `etag` in the read-modify-write cycle to perform policy updates in order to avoid race conditions: An `etag` is returned in the response to `getIamPolicy`, and systems are expected to put that etag in the request to `setIamPolicy` to ensure that their change will be applied to the same version of the policy. **Important:** If you use IAM Conditions, you must include the `etag` field whenever you call `setIamPolicy`. If you omit this field, then IAM allows you to overwrite a version `3` policy with a version `1` policy, and all of the conditions in the version `3` policy are lost.
	Etag                   pulumi.StringPtrInput
	GameServerDeploymentId pulumi.StringInput
	IamOwned               pulumi.BoolPtrInput
	Location               pulumi.StringInput
	Project                pulumi.StringInput
	// If more than one rule is specified, the rules are applied in the following manner: - All matching LOG rules are always applied. - If any DENY/DENY_WITH_LOG rule matches, permission is denied. Logging will be applied if one or more matching rule requires logging. - Otherwise, if any ALLOW/ALLOW_WITH_LOG rule matches, permission is granted. Logging will be applied if one or more matching rule requires logging. - Otherwise, if no rule applies, permission is denied.
	Rules RuleArrayInput
	// OPTIONAL: A FieldMask specifying which fields of the policy to modify. Only the fields in the mask will be modified. If no mask is provided, the following default mask is used: `paths: "bindings, etag"`
	UpdateMask pulumi.StringPtrInput
	// Specifies the format of the policy. Valid values are `0`, `1`, and `3`. Requests that specify an invalid value are rejected. Any operation that affects conditional role bindings must specify version `3`. This requirement applies to the following operations: * Getting a policy that includes a conditional role binding * Adding a conditional role binding to a policy * Changing a conditional role binding in a policy * Removing any role binding, with or without a condition, from a policy that includes conditions **Important:** If you use IAM Conditions, you must include the `etag` field whenever you call `setIamPolicy`. If you omit this field, then IAM allows you to overwrite a version `3` policy with a version `1` policy, and all of the conditions in the version `3` policy are lost. If a policy does not include any conditions, operations on that policy may specify any valid version or leave the field unset. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
	Version pulumi.IntPtrInput
}

The set of arguments for constructing a GameServerDeploymentIamPolicy resource.

func (GameServerDeploymentIamPolicyArgs) ElementType 

func (GameServerDeploymentIamPolicyArgs) ElementType() reflect.Type

type GameServerDeploymentIamPolicyInput 

type GameServerDeploymentIamPolicyInput interface {
	pulumi.Input

	ToGameServerDeploymentIamPolicyOutput() GameServerDeploymentIamPolicyOutput
	ToGameServerDeploymentIamPolicyOutputWithContext(ctx context.Context) GameServerDeploymentIamPolicyOutput
}

type GameServerDeploymentIamPolicyOutput 

type GameServerDeploymentIamPolicyOutput struct {
	*pulumi.OutputState
}

func (GameServerDeploymentIamPolicyOutput) ElementType 

func (GameServerDeploymentIamPolicyOutput) ElementType() reflect.Type

func (GameServerDeploymentIamPolicyOutput) ToGameServerDeploymentIamPolicyOutput 

func (o GameServerDeploymentIamPolicyOutput) ToGameServerDeploymentIamPolicyOutput() GameServerDeploymentIamPolicyOutput

func (GameServerDeploymentIamPolicyOutput) ToGameServerDeploymentIamPolicyOutputWithContext 

func (o GameServerDeploymentIamPolicyOutput) ToGameServerDeploymentIamPolicyOutputWithContext(ctx context.Context) GameServerDeploymentIamPolicyOutput

type GameServerDeploymentIamPolicyState 

type GameServerDeploymentIamPolicyState struct {
	// Specifies cloud audit logging configuration for this policy.
	AuditConfigs AuditConfigResponseArrayInput
	// Associates a list of `members` to a `role`. Optionally, may specify a `condition` that determines how and when the `bindings` are applied. Each of the `bindings` must contain at least one member.
	Bindings BindingResponseArrayInput
	// `etag` is used for optimistic concurrency control as a way to help prevent simultaneous updates of a policy from overwriting each other. It is strongly suggested that systems make use of the `etag` in the read-modify-write cycle to perform policy updates in order to avoid race conditions: An `etag` is returned in the response to `getIamPolicy`, and systems are expected to put that etag in the request to `setIamPolicy` to ensure that their change will be applied to the same version of the policy. **Important:** If you use IAM Conditions, you must include the `etag` field whenever you call `setIamPolicy`. If you omit this field, then IAM allows you to overwrite a version `3` policy with a version `1` policy, and all of the conditions in the version `3` policy are lost.
	Etag     pulumi.StringPtrInput
	IamOwned pulumi.BoolPtrInput
	// If more than one rule is specified, the rules are applied in the following manner: - All matching LOG rules are always applied. - If any DENY/DENY_WITH_LOG rule matches, permission is denied. Logging will be applied if one or more matching rule requires logging. - Otherwise, if any ALLOW/ALLOW_WITH_LOG rule matches, permission is granted. Logging will be applied if one or more matching rule requires logging. - Otherwise, if no rule applies, permission is denied.
	Rules RuleResponseArrayInput
	// Specifies the format of the policy. Valid values are `0`, `1`, and `3`. Requests that specify an invalid value are rejected. Any operation that affects conditional role bindings must specify version `3`. This requirement applies to the following operations: * Getting a policy that includes a conditional role binding * Adding a conditional role binding to a policy * Changing a conditional role binding in a policy * Removing any role binding, with or without a condition, from a policy that includes conditions **Important:** If you use IAM Conditions, you must include the `etag` field whenever you call `setIamPolicy`. If you omit this field, then IAM allows you to overwrite a version `3` policy with a version `1` policy, and all of the conditions in the version `3` policy are lost. If a policy does not include any conditions, operations on that policy may specify any valid version or leave the field unset. To learn which resources support conditions in their IAM policies, see the [IAM documentation](https://cloud.google.com/iam/help/conditions/resource-policies).
	Version pulumi.IntPtrInput
}

func (GameServerDeploymentIamPolicyState) ElementType 

func (GameServerDeploymentIamPolicyState) ElementType() reflect.Type

type GameServerDeploymentInput 

type GameServerDeploymentInput interface {
	pulumi.Input

	ToGameServerDeploymentOutput() GameServerDeploymentOutput
	ToGameServerDeploymentOutputWithContext(ctx context.Context) GameServerDeploymentOutput
}

type GameServerDeploymentOutput 

type GameServerDeploymentOutput struct {
	*pulumi.OutputState
}

func (GameServerDeploymentOutput) ElementType 

func (GameServerDeploymentOutput) ElementType() reflect.Type

func (GameServerDeploymentOutput) ToGameServerDeploymentOutput 

func (o GameServerDeploymentOutput) ToGameServerDeploymentOutput() GameServerDeploymentOutput

func (GameServerDeploymentOutput) ToGameServerDeploymentOutputWithContext 

func (o GameServerDeploymentOutput) ToGameServerDeploymentOutputWithContext(ctx context.Context) GameServerDeploymentOutput

type GameServerDeploymentState 

type GameServerDeploymentState struct {
	// The creation time.
	CreateTime pulumi.StringPtrInput
	// Human readable description of the game server delpoyment.
	Description pulumi.StringPtrInput
	// ETag of the resource.
	Etag pulumi.StringPtrInput
	// The labels associated with this game server deployment. Each label is a key-value pair.
	Labels pulumi.StringMapInput
	// The resource name of the game server deployment, in the following form: `projects/{project}/locations/{location}/gameServerDeployments/{deployment}`. For example, `projects/my-project/locations/global/gameServerDeployments/my-deployment`.
	Name pulumi.StringPtrInput
	// The last-modified time.
	UpdateTime pulumi.StringPtrInput
}

func (GameServerDeploymentState) ElementType 

func (GameServerDeploymentState) ElementType() reflect.Type

type GkeClusterReference 

type GkeClusterReference struct {
	// The full or partial name of a GKE cluster, using one of the following forms: * `projects/{project}/locations/{location}/clusters/{cluster}` * `locations/{location}/clusters/{cluster}` * `{cluster}` If project and location are not specified, the project and location of the GameServerCluster resource are used to generate the full name of the GKE cluster.
	Cluster *string `pulumi:"cluster"`
}

A reference to a GKE cluster.

type GkeClusterReferenceArgs 

type GkeClusterReferenceArgs struct {
	// The full or partial name of a GKE cluster, using one of the following forms: * `projects/{project}/locations/{location}/clusters/{cluster}` * `locations/{location}/clusters/{cluster}` * `{cluster}` If project and location are not specified, the project and location of the GameServerCluster resource are used to generate the full name of the GKE cluster.
	Cluster pulumi.StringPtrInput `pulumi:"cluster"`
}

A reference to a GKE cluster.

func (GkeClusterReferenceArgs) ElementType 

func (GkeClusterReferenceArgs) ElementType() reflect.Type

func (GkeClusterReferenceArgs) ToGkeClusterReferenceOutput 

func (i GkeClusterReferenceArgs) ToGkeClusterReferenceOutput() GkeClusterReferenceOutput

func (GkeClusterReferenceArgs) ToGkeClusterReferenceOutputWithContext 

func (i GkeClusterReferenceArgs) ToGkeClusterReferenceOutputWithContext(ctx context.Context) GkeClusterReferenceOutput

func (GkeClusterReferenceArgs) ToGkeClusterReferencePtrOutput 

func (i GkeClusterReferenceArgs) ToGkeClusterReferencePtrOutput() GkeClusterReferencePtrOutput

func (GkeClusterReferenceArgs) ToGkeClusterReferencePtrOutputWithContext 

func (i GkeClusterReferenceArgs) ToGkeClusterReferencePtrOutputWithContext(ctx context.Context) GkeClusterReferencePtrOutput

type GkeClusterReferenceInput 

type GkeClusterReferenceInput interface {
	pulumi.Input

	ToGkeClusterReferenceOutput() GkeClusterReferenceOutput
	ToGkeClusterReferenceOutputWithContext(context.Context) GkeClusterReferenceOutput
}

GkeClusterReferenceInput is an input type that accepts GkeClusterReferenceArgs and GkeClusterReferenceOutput values. You can construct a concrete instance of `GkeClusterReferenceInput` via: 

GkeClusterReferenceArgs{...}

type GkeClusterReferenceOutput 

type GkeClusterReferenceOutput struct{ *pulumi.OutputState }

A reference to a GKE cluster.

func (GkeClusterReferenceOutput) Cluster 

func (o GkeClusterReferenceOutput) Cluster() pulumi.StringPtrOutput

The full or partial name of a GKE cluster, using one of the following forms: * `projects/{project}/locations/{location}/clusters/{cluster}` * `locations/{location}/clusters/{cluster}` * `{cluster}` If project and location are not specified, the project and location of the GameServerCluster resource are used to generate the full name of the GKE cluster.

func (GkeClusterReferenceOutput) ElementType 

func (GkeClusterReferenceOutput) ElementType() reflect.Type

func (GkeClusterReferenceOutput) ToGkeClusterReferenceOutput 

func (o GkeClusterReferenceOutput) ToGkeClusterReferenceOutput() GkeClusterReferenceOutput

func (GkeClusterReferenceOutput) ToGkeClusterReferenceOutputWithContext 

func (o GkeClusterReferenceOutput) ToGkeClusterReferenceOutputWithContext(ctx context.Context) GkeClusterReferenceOutput

func (GkeClusterReferenceOutput) ToGkeClusterReferencePtrOutput 

func (o GkeClusterReferenceOutput) ToGkeClusterReferencePtrOutput() GkeClusterReferencePtrOutput

func (GkeClusterReferenceOutput) ToGkeClusterReferencePtrOutputWithContext 

func (o GkeClusterReferenceOutput) ToGkeClusterReferencePtrOutputWithContext(ctx context.Context) GkeClusterReferencePtrOutput

type GkeClusterReferencePtrInput 

type GkeClusterReferencePtrInput interface {
	pulumi.Input

	ToGkeClusterReferencePtrOutput() GkeClusterReferencePtrOutput
	ToGkeClusterReferencePtrOutputWithContext(context.Context) GkeClusterReferencePtrOutput
}

GkeClusterReferencePtrInput is an input type that accepts GkeClusterReferenceArgs, GkeClusterReferencePtr and GkeClusterReferencePtrOutput values. You can construct a concrete instance of `GkeClusterReferencePtrInput` via: 

        GkeClusterReferenceArgs{...}

or:

        nil

func GkeClusterReferencePtr 

func GkeClusterReferencePtr(v *GkeClusterReferenceArgs) GkeClusterReferencePtrInput

type GkeClusterReferencePtrOutput 

type GkeClusterReferencePtrOutput struct{ *pulumi.OutputState }

func (GkeClusterReferencePtrOutput) Cluster 

func (o GkeClusterReferencePtrOutput) Cluster() pulumi.StringPtrOutput

The full or partial name of a GKE cluster, using one of the following forms: * `projects/{project}/locations/{location}/clusters/{cluster}` * `locations/{location}/clusters/{cluster}` * `{cluster}` If project and location are not specified, the project and location of the GameServerCluster resource are used to generate the full name of the GKE cluster.

func (GkeClusterReferencePtrOutput) Elem 

func (o GkeClusterReferencePtrOutput) Elem() GkeClusterReferenceOutput

func (GkeClusterReferencePtrOutput) ElementType 

func (GkeClusterReferencePtrOutput) ElementType() reflect.Type

func (GkeClusterReferencePtrOutput) ToGkeClusterReferencePtrOutput 

func (o GkeClusterReferencePtrOutput) ToGkeClusterReferencePtrOutput() GkeClusterReferencePtrOutput

func (GkeClusterReferencePtrOutput) ToGkeClusterReferencePtrOutputWithContext 

func (o GkeClusterReferencePtrOutput) ToGkeClusterReferencePtrOutputWithContext(ctx context.Context) GkeClusterReferencePtrOutput

type GkeClusterReferenceResponse 

type GkeClusterReferenceResponse struct {
	// The full or partial name of a GKE cluster, using one of the following forms: * `projects/{project}/locations/{location}/clusters/{cluster}` * `locations/{location}/clusters/{cluster}` * `{cluster}` If project and location are not specified, the project and location of the GameServerCluster resource are used to generate the full name of the GKE cluster.
	Cluster string `pulumi:"cluster"`
}

A reference to a GKE cluster.

type GkeClusterReferenceResponseArgs 

type GkeClusterReferenceResponseArgs struct {
	// The full or partial name of a GKE cluster, using one of the following forms: * `projects/{project}/locations/{location}/clusters/{cluster}` * `locations/{location}/clusters/{cluster}` * `{cluster}` If project and location are not specified, the project and location of the GameServerCluster resource are used to generate the full name of the GKE cluster.
	Cluster pulumi.StringInput `pulumi:"cluster"`
}

A reference to a GKE cluster.

func (GkeClusterReferenceResponseArgs) ElementType 

func (GkeClusterReferenceResponseArgs) ElementType() reflect.Type

func (GkeClusterReferenceResponseArgs) ToGkeClusterReferenceResponseOutput 

func (i GkeClusterReferenceResponseArgs) ToGkeClusterReferenceResponseOutput() GkeClusterReferenceResponseOutput

func (GkeClusterReferenceResponseArgs) ToGkeClusterReferenceResponseOutputWithContext 

func (i GkeClusterReferenceResponseArgs) ToGkeClusterReferenceResponseOutputWithContext(ctx context.Context) GkeClusterReferenceResponseOutput

func (GkeClusterReferenceResponseArgs) ToGkeClusterReferenceResponsePtrOutput 

func (i GkeClusterReferenceResponseArgs) ToGkeClusterReferenceResponsePtrOutput() GkeClusterReferenceResponsePtrOutput

func (GkeClusterReferenceResponseArgs) ToGkeClusterReferenceResponsePtrOutputWithContext 

func (i GkeClusterReferenceResponseArgs) ToGkeClusterReferenceResponsePtrOutputWithContext(ctx context.Context) GkeClusterReferenceResponsePtrOutput

type GkeClusterReferenceResponseInput 

type GkeClusterReferenceResponseInput interface {
	pulumi.Input

	ToGkeClusterReferenceResponseOutput() GkeClusterReferenceResponseOutput
	ToGkeClusterReferenceResponseOutputWithContext(context.Context) GkeClusterReferenceResponseOutput
}

GkeClusterReferenceResponseInput is an input type that accepts GkeClusterReferenceResponseArgs and GkeClusterReferenceResponseOutput values. You can construct a concrete instance of `GkeClusterReferenceResponseInput` via: 

GkeClusterReferenceResponseArgs{...}

type GkeClusterReferenceResponseOutput 

type GkeClusterReferenceResponseOutput struct{ *pulumi.OutputState }

A reference to a GKE cluster.

func (GkeClusterReferenceResponseOutput) Cluster 

func (o GkeClusterReferenceResponseOutput) Cluster() pulumi.StringOutput

The full or partial name of a GKE cluster, using one of the following forms: * `projects/{project}/locations/{location}/clusters/{cluster}` * `locations/{location}/clusters/{cluster}` * `{cluster}` If project and location are not specified, the project and location of the GameServerCluster resource are used to generate the full name of the GKE cluster.

func (GkeClusterReferenceResponseOutput) ElementType 

func (GkeClusterReferenceResponseOutput) ElementType() reflect.Type

func (GkeClusterReferenceResponseOutput) ToGkeClusterReferenceResponseOutput 

func (o GkeClusterReferenceResponseOutput) ToGkeClusterReferenceResponseOutput() GkeClusterReferenceResponseOutput

func (GkeClusterReferenceResponseOutput) ToGkeClusterReferenceResponseOutputWithContext 

func (o GkeClusterReferenceResponseOutput) ToGkeClusterReferenceResponseOutputWithContext(ctx context.Context) GkeClusterReferenceResponseOutput

func (GkeClusterReferenceResponseOutput) ToGkeClusterReferenceResponsePtrOutput 

func (o GkeClusterReferenceResponseOutput) ToGkeClusterReferenceResponsePtrOutput() GkeClusterReferenceResponsePtrOutput

func (GkeClusterReferenceResponseOutput) ToGkeClusterReferenceResponsePtrOutputWithContext 

func (o GkeClusterReferenceResponseOutput) ToGkeClusterReferenceResponsePtrOutputWithContext(ctx context.Context) GkeClusterReferenceResponsePtrOutput

type GkeClusterReferenceResponsePtrInput 

type GkeClusterReferenceResponsePtrInput interface {
	pulumi.Input

	ToGkeClusterReferenceResponsePtrOutput() GkeClusterReferenceResponsePtrOutput
	ToGkeClusterReferenceResponsePtrOutputWithContext(context.Context) GkeClusterReferenceResponsePtrOutput
}

GkeClusterReferenceResponsePtrInput is an input type that accepts GkeClusterReferenceResponseArgs, GkeClusterReferenceResponsePtr and GkeClusterReferenceResponsePtrOutput values. You can construct a concrete instance of `GkeClusterReferenceResponsePtrInput` via: 

        GkeClusterReferenceResponseArgs{...}

or:

        nil

func GkeClusterReferenceResponsePtr 

func GkeClusterReferenceResponsePtr(v *GkeClusterReferenceResponseArgs) GkeClusterReferenceResponsePtrInput

type GkeClusterReferenceResponsePtrOutput 

type GkeClusterReferenceResponsePtrOutput struct{ *pulumi.OutputState }

func (GkeClusterReferenceResponsePtrOutput) Cluster 

func (o GkeClusterReferenceResponsePtrOutput) Cluster() pulumi.StringPtrOutput

The full or partial name of a GKE cluster, using one of the following forms: * `projects/{project}/locations/{location}/clusters/{cluster}` * `locations/{location}/clusters/{cluster}` * `{cluster}` If project and location are not specified, the project and location of the GameServerCluster resource are used to generate the full name of the GKE cluster.

func (GkeClusterReferenceResponsePtrOutput) Elem 

func (o GkeClusterReferenceResponsePtrOutput) Elem() GkeClusterReferenceResponseOutput

func (GkeClusterReferenceResponsePtrOutput) ElementType 

func (GkeClusterReferenceResponsePtrOutput) ElementType() reflect.Type

func (GkeClusterReferenceResponsePtrOutput) ToGkeClusterReferenceResponsePtrOutput 

func (o GkeClusterReferenceResponsePtrOutput) ToGkeClusterReferenceResponsePtrOutput() GkeClusterReferenceResponsePtrOutput

func (GkeClusterReferenceResponsePtrOutput) ToGkeClusterReferenceResponsePtrOutputWithContext 

func (o GkeClusterReferenceResponsePtrOutput) ToGkeClusterReferenceResponsePtrOutputWithContext(ctx context.Context) GkeClusterReferenceResponsePtrOutput

type LabelSelector 

type LabelSelector struct {
	// Resource labels for this selector.
	Labels map[string]string `pulumi:"labels"`
}

The label selector, used to group labels on the resources.

type LabelSelectorArgs 

type LabelSelectorArgs struct {
	// Resource labels for this selector.
	Labels pulumi.StringMapInput `pulumi:"labels"`
}

The label selector, used to group labels on the resources.

func (LabelSelectorArgs) ElementType 

func (LabelSelectorArgs) ElementType() reflect.Type

func (LabelSelectorArgs) ToLabelSelectorOutput 

func (i LabelSelectorArgs) ToLabelSelectorOutput() LabelSelectorOutput

func (LabelSelectorArgs) ToLabelSelectorOutputWithContext 

func (i LabelSelectorArgs) ToLabelSelectorOutputWithContext(ctx context.Context) LabelSelectorOutput

type LabelSelectorArray 

type LabelSelectorArray []LabelSelectorInput

func (LabelSelectorArray) ElementType 

func (LabelSelectorArray) ElementType() reflect.Type

func (LabelSelectorArray) ToLabelSelectorArrayOutput 

func (i LabelSelectorArray) ToLabelSelectorArrayOutput() LabelSelectorArrayOutput

func (LabelSelectorArray) ToLabelSelectorArrayOutputWithContext 

func (i LabelSelectorArray) ToLabelSelectorArrayOutputWithContext(ctx context.Context) LabelSelectorArrayOutput

type LabelSelectorArrayInput 

type LabelSelectorArrayInput interface {
	pulumi.Input

	ToLabelSelectorArrayOutput() LabelSelectorArrayOutput
	ToLabelSelectorArrayOutputWithContext(context.Context) LabelSelectorArrayOutput
}

LabelSelectorArrayInput is an input type that accepts LabelSelectorArray and LabelSelectorArrayOutput values. You can construct a concrete instance of `LabelSelectorArrayInput` via: 

LabelSelectorArray{ LabelSelectorArgs{...} }

type LabelSelectorArrayOutput 

type LabelSelectorArrayOutput struct{ *pulumi.OutputState }

func (LabelSelectorArrayOutput) ElementType 

func (LabelSelectorArrayOutput) ElementType() reflect.Type

func (LabelSelectorArrayOutput) Index 

func (o LabelSelectorArrayOutput) Index(i pulumi.IntInput) LabelSelectorOutput

func (LabelSelectorArrayOutput) ToLabelSelectorArrayOutput 

func (o LabelSelectorArrayOutput) ToLabelSelectorArrayOutput() LabelSelectorArrayOutput

func (LabelSelectorArrayOutput) ToLabelSelectorArrayOutputWithContext 

func (o LabelSelectorArrayOutput) ToLabelSelectorArrayOutputWithContext(ctx context.Context) LabelSelectorArrayOutput

type LabelSelectorInput 

type LabelSelectorInput interface {
	pulumi.Input

	ToLabelSelectorOutput() LabelSelectorOutput
	ToLabelSelectorOutputWithContext(context.Context) LabelSelectorOutput
}

LabelSelectorInput is an input type that accepts LabelSelectorArgs and LabelSelectorOutput values. You can construct a concrete instance of `LabelSelectorInput` via: 

LabelSelectorArgs{...}

type LabelSelectorOutput 

type LabelSelectorOutput struct{ *pulumi.OutputState }

The label selector, used to group labels on the resources.

func (LabelSelectorOutput) ElementType 

func (LabelSelectorOutput) ElementType() reflect.Type

func (LabelSelectorOutput) Labels 

func (o LabelSelectorOutput) Labels() pulumi.StringMapOutput

Resource labels for this selector.

func (LabelSelectorOutput) ToLabelSelectorOutput 

func (o LabelSelectorOutput) ToLabelSelectorOutput() LabelSelectorOutput

func (LabelSelectorOutput) ToLabelSelectorOutputWithContext 

func (o LabelSelectorOutput) ToLabelSelectorOutputWithContext(ctx context.Context) LabelSelectorOutput

type LabelSelectorResponse 

type LabelSelectorResponse struct {
	// Resource labels for this selector.
	Labels map[string]string `pulumi:"labels"`
}

The label selector, used to group labels on the resources.

type LabelSelectorResponseArgs 

type LabelSelectorResponseArgs struct {
	// Resource labels for this selector.
	Labels pulumi.StringMapInput `pulumi:"labels"`
}

The label selector, used to group labels on the resources.

func (LabelSelectorResponseArgs) ElementType 

func (LabelSelectorResponseArgs) ElementType() reflect.Type

func (LabelSelectorResponseArgs) ToLabelSelectorResponseOutput 

func (i LabelSelectorResponseArgs) ToLabelSelectorResponseOutput() LabelSelectorResponseOutput

func (LabelSelectorResponseArgs) ToLabelSelectorResponseOutputWithContext 

func (i LabelSelectorResponseArgs) ToLabelSelectorResponseOutputWithContext(ctx context.Context) LabelSelectorResponseOutput

type LabelSelectorResponseArray 

type LabelSelectorResponseArray []LabelSelectorResponseInput

func (LabelSelectorResponseArray) ElementType 

func (LabelSelectorResponseArray) ElementType() reflect.Type

func (LabelSelectorResponseArray) ToLabelSelectorResponseArrayOutput 

func (i LabelSelectorResponseArray) ToLabelSelectorResponseArrayOutput() LabelSelectorResponseArrayOutput

func (LabelSelectorResponseArray) ToLabelSelectorResponseArrayOutputWithContext 

func (i LabelSelectorResponseArray) ToLabelSelectorResponseArrayOutputWithContext(ctx context.Context) LabelSelectorResponseArrayOutput

type LabelSelectorResponseArrayInput 

type LabelSelectorResponseArrayInput interface {
	pulumi.Input

	ToLabelSelectorResponseArrayOutput() LabelSelectorResponseArrayOutput
	ToLabelSelectorResponseArrayOutputWithContext(context.Context) LabelSelectorResponseArrayOutput
}

LabelSelectorResponseArrayInput is an input type that accepts LabelSelectorResponseArray and LabelSelectorResponseArrayOutput values. You can construct a concrete instance of `LabelSelectorResponseArrayInput` via: 

LabelSelectorResponseArray{ LabelSelectorResponseArgs{...} }

type LabelSelectorResponseArrayOutput 

type LabelSelectorResponseArrayOutput struct{ *pulumi.OutputState }

func (LabelSelectorResponseArrayOutput) ElementType 

func (LabelSelectorResponseArrayOutput) ElementType() reflect.Type

func (LabelSelectorResponseArrayOutput) Index 

func (o LabelSelectorResponseArrayOutput) Index(i pulumi.IntInput) LabelSelectorResponseOutput

func (LabelSelectorResponseArrayOutput) ToLabelSelectorResponseArrayOutput 

func (o LabelSelectorResponseArrayOutput) ToLabelSelectorResponseArrayOutput() LabelSelectorResponseArrayOutput

func (LabelSelectorResponseArrayOutput) ToLabelSelectorResponseArrayOutputWithContext 

func (o LabelSelectorResponseArrayOutput) ToLabelSelectorResponseArrayOutputWithContext(ctx context.Context) LabelSelectorResponseArrayOutput

type LabelSelectorResponseInput 

type LabelSelectorResponseInput interface {
	pulumi.Input

	ToLabelSelectorResponseOutput() LabelSelectorResponseOutput
	ToLabelSelectorResponseOutputWithContext(context.Context) LabelSelectorResponseOutput
}

LabelSelectorResponseInput is an input type that accepts LabelSelectorResponseArgs and LabelSelectorResponseOutput values. You can construct a concrete instance of `LabelSelectorResponseInput` via: 

LabelSelectorResponseArgs{...}

type LabelSelectorResponseOutput 

type LabelSelectorResponseOutput struct{ *pulumi.OutputState }

The label selector, used to group labels on the resources.

func (LabelSelectorResponseOutput) ElementType 

func (LabelSelectorResponseOutput) ElementType() reflect.Type

func (LabelSelectorResponseOutput) Labels 

func (o LabelSelectorResponseOutput) Labels() pulumi.StringMapOutput

Resource labels for this selector.

func (LabelSelectorResponseOutput) ToLabelSelectorResponseOutput 

func (o LabelSelectorResponseOutput) ToLabelSelectorResponseOutput() LabelSelectorResponseOutput

func (LabelSelectorResponseOutput) ToLabelSelectorResponseOutputWithContext 

func (o LabelSelectorResponseOutput) ToLabelSelectorResponseOutputWithContext(ctx context.Context) LabelSelectorResponseOutput

type LogConfig 

type LogConfig struct {
	// Cloud audit options.
	CloudAudit *CloudAuditOptions `pulumi:"cloudAudit"`
	// Counter options.
	Counter *CounterOptions `pulumi:"counter"`
	// Data access options.
	DataAccess *DataAccessOptions `pulumi:"dataAccess"`
}

Specifies what kind of log the caller must write

type LogConfigArgs 

type LogConfigArgs struct {
	// Cloud audit options.
	CloudAudit CloudAuditOptionsPtrInput `pulumi:"cloudAudit"`
	// Counter options.
	Counter CounterOptionsPtrInput `pulumi:"counter"`
	// Data access options.
	DataAccess DataAccessOptionsPtrInput `pulumi:"dataAccess"`
}

Specifies what kind of log the caller must write

func (LogConfigArgs) ElementType 

func (LogConfigArgs) ElementType() reflect.Type

func (LogConfigArgs) ToLogConfigOutput 

func (i LogConfigArgs) ToLogConfigOutput() LogConfigOutput

func (LogConfigArgs) ToLogConfigOutputWithContext 

func (i LogConfigArgs) ToLogConfigOutputWithContext(ctx context.Context) LogConfigOutput

type LogConfigArray 

type LogConfigArray []LogConfigInput

func (LogConfigArray) ElementType 

func (LogConfigArray) ElementType() reflect.Type

func (LogConfigArray) ToLogConfigArrayOutput 

func (i LogConfigArray) ToLogConfigArrayOutput() LogConfigArrayOutput

func (LogConfigArray) ToLogConfigArrayOutputWithContext 

func (i LogConfigArray) ToLogConfigArrayOutputWithContext(ctx context.Context) LogConfigArrayOutput

type LogConfigArrayInput 

type LogConfigArrayInput interface {
	pulumi.Input

	ToLogConfigArrayOutput() LogConfigArrayOutput
	ToLogConfigArrayOutputWithContext(context.Context) LogConfigArrayOutput
}

LogConfigArrayInput is an input type that accepts LogConfigArray and LogConfigArrayOutput values. You can construct a concrete instance of `LogConfigArrayInput` via: 

LogConfigArray{ LogConfigArgs{...} }

type LogConfigArrayOutput 

type LogConfigArrayOutput struct{ *pulumi.OutputState }

func (LogConfigArrayOutput) ElementType 

func (LogConfigArrayOutput) ElementType() reflect.Type

func (LogConfigArrayOutput) Index 

func (o LogConfigArrayOutput) Index(i pulumi.IntInput) LogConfigOutput

func (LogConfigArrayOutput) ToLogConfigArrayOutput 

func (o LogConfigArrayOutput) ToLogConfigArrayOutput() LogConfigArrayOutput

func (LogConfigArrayOutput) ToLogConfigArrayOutputWithContext 

func (o LogConfigArrayOutput) ToLogConfigArrayOutputWithContext(ctx context.Context) LogConfigArrayOutput

type LogConfigInput 

type LogConfigInput interface {
	pulumi.Input

	ToLogConfigOutput() LogConfigOutput
	ToLogConfigOutputWithContext(context.Context) LogConfigOutput
}

LogConfigInput is an input type that accepts LogConfigArgs and LogConfigOutput values. You can construct a concrete instance of `LogConfigInput` via: 

LogConfigArgs{...}

type LogConfigOutput 

type LogConfigOutput struct{ *pulumi.OutputState }

Specifies what kind of log the caller must write

func (LogConfigOutput) CloudAudit 

func (o LogConfigOutput) CloudAudit() CloudAuditOptionsPtrOutput

Cloud audit options.

func (LogConfigOutput) Counter 

func (o LogConfigOutput) Counter() CounterOptionsPtrOutput

Counter options.

func (LogConfigOutput) DataAccess 

func (o LogConfigOutput) DataAccess() DataAccessOptionsPtrOutput

Data access options.

func (LogConfigOutput) ElementType 

func (LogConfigOutput) ElementType() reflect.Type

func (LogConfigOutput) ToLogConfigOutput 

func (o LogConfigOutput) ToLogConfigOutput() LogConfigOutput

func (LogConfigOutput) ToLogConfigOutputWithContext 

func (o LogConfigOutput) ToLogConfigOutputWithContext(ctx context.Context) LogConfigOutput

type LogConfigResponse 

type LogConfigResponse struct {
	// Cloud audit options.
	CloudAudit CloudAuditOptionsResponse `pulumi:"cloudAudit"`
	// Counter options.
	Counter CounterOptionsResponse `pulumi:"counter"`
	// Data access options.
	DataAccess DataAccessOptionsResponse `pulumi:"dataAccess"`
}

Specifies what kind of log the caller must write

type LogConfigResponseArgs 

type LogConfigResponseArgs struct {
	// Cloud audit options.
	CloudAudit CloudAuditOptionsResponseInput `pulumi:"cloudAudit"`
	// Counter options.
	Counter CounterOptionsResponseInput `pulumi:"counter"`
	// Data access options.
	DataAccess DataAccessOptionsResponseInput `pulumi:"dataAccess"`
}

Specifies what kind of log the caller must write

func (LogConfigResponseArgs) ElementType 

func (LogConfigResponseArgs) ElementType() reflect.Type

func (LogConfigResponseArgs) ToLogConfigResponseOutput 

func (i LogConfigResponseArgs) ToLogConfigResponseOutput() LogConfigResponseOutput

func (LogConfigResponseArgs) ToLogConfigResponseOutputWithContext 

func (i LogConfigResponseArgs) ToLogConfigResponseOutputWithContext(ctx context.Context) LogConfigResponseOutput

type LogConfigResponseArray 

type LogConfigResponseArray []LogConfigResponseInput

func (LogConfigResponseArray) ElementType 

func (LogConfigResponseArray) ElementType() reflect.Type

func (LogConfigResponseArray) ToLogConfigResponseArrayOutput 

func (i LogConfigResponseArray) ToLogConfigResponseArrayOutput() LogConfigResponseArrayOutput

func (LogConfigResponseArray) ToLogConfigResponseArrayOutputWithContext 

func (i LogConfigResponseArray) ToLogConfigResponseArrayOutputWithContext(ctx context.Context) LogConfigResponseArrayOutput

type LogConfigResponseArrayInput 

type LogConfigResponseArrayInput interface {
	pulumi.Input

	ToLogConfigResponseArrayOutput() LogConfigResponseArrayOutput
	ToLogConfigResponseArrayOutputWithContext(context.Context) LogConfigResponseArrayOutput
}

LogConfigResponseArrayInput is an input type that accepts LogConfigResponseArray and LogConfigResponseArrayOutput values. You can construct a concrete instance of `LogConfigResponseArrayInput` via: 

LogConfigResponseArray{ LogConfigResponseArgs{...} }

type LogConfigResponseArrayOutput 

type LogConfigResponseArrayOutput struct{ *pulumi.OutputState }

func (LogConfigResponseArrayOutput) ElementType 

func (LogConfigResponseArrayOutput) ElementType() reflect.Type

func (LogConfigResponseArrayOutput) Index 

func (o LogConfigResponseArrayOutput) Index(i pulumi.IntInput) LogConfigResponseOutput

func (LogConfigResponseArrayOutput) ToLogConfigResponseArrayOutput 

func (o LogConfigResponseArrayOutput) ToLogConfigResponseArrayOutput() LogConfigResponseArrayOutput

func (LogConfigResponseArrayOutput) ToLogConfigResponseArrayOutputWithContext 

func (o LogConfigResponseArrayOutput) ToLogConfigResponseArrayOutputWithContext(ctx context.Context) LogConfigResponseArrayOutput

type LogConfigResponseInput 

type LogConfigResponseInput interface {
	pulumi.Input

	ToLogConfigResponseOutput() LogConfigResponseOutput
	ToLogConfigResponseOutputWithContext(context.Context) LogConfigResponseOutput
}

LogConfigResponseInput is an input type that accepts LogConfigResponseArgs and LogConfigResponseOutput values. You can construct a concrete instance of `LogConfigResponseInput` via: 

LogConfigResponseArgs{...}

type LogConfigResponseOutput 

type LogConfigResponseOutput struct{ *pulumi.OutputState }

Specifies what kind of log the caller must write

func (LogConfigResponseOutput) CloudAudit 

func (o LogConfigResponseOutput) CloudAudit() CloudAuditOptionsResponseOutput

Cloud audit options.

func (LogConfigResponseOutput) Counter 

func (o LogConfigResponseOutput) Counter() CounterOptionsResponseOutput

Counter options.

func (LogConfigResponseOutput) DataAccess 

func (o LogConfigResponseOutput) DataAccess() DataAccessOptionsResponseOutput

Data access options.

func (LogConfigResponseOutput) ElementType 

func (LogConfigResponseOutput) ElementType() reflect.Type

func (LogConfigResponseOutput) ToLogConfigResponseOutput 

func (o LogConfigResponseOutput) ToLogConfigResponseOutput() LogConfigResponseOutput

func (LogConfigResponseOutput) ToLogConfigResponseOutputWithContext 

func (o LogConfigResponseOutput) ToLogConfigResponseOutputWithContext(ctx context.Context) LogConfigResponseOutput

type Realm 

type Realm struct {
	pulumi.CustomResourceState

	// The creation time.
	CreateTime pulumi.StringOutput `pulumi:"createTime"`
	// Human readable description of the realm.
	Description pulumi.StringOutput `pulumi:"description"`
	// ETag of the resource.
	Etag pulumi.StringOutput `pulumi:"etag"`
	// The labels associated with this realm. Each label is a key-value pair.
	Labels pulumi.StringMapOutput `pulumi:"labels"`
	// The resource name of the realm, in the following form: `projects/{project}/locations/{location}/realms/{realm}`. For example, `projects/my-project/locations/{location}/realms/my-realm`.
	Name pulumi.StringOutput `pulumi:"name"`
	// Required. Time zone where all policies targeting this realm are evaluated. The value of this field must be from the IANA time zone database: https://www.iana.org/time-zones.
	TimeZone pulumi.StringOutput `pulumi:"timeZone"`
	// The last-modified time.
	UpdateTime pulumi.StringOutput `pulumi:"updateTime"`
}

Creates a new realm in a given project and location.

func GetRealm 

func GetRealm(ctx *pulumi.Context,
	name string, id pulumi.IDInput, state *RealmState, opts ...pulumi.ResourceOption) (*Realm, error)

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

func NewRealm 

func NewRealm(ctx *pulumi.Context,
	name string, args *RealmArgs, opts ...pulumi.ResourceOption) (*Realm, error)

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

func (*Realm) ElementType 

func (*Realm) ElementType() reflect.Type

func (*Realm) ToRealmOutput 

func (i *Realm) ToRealmOutput() RealmOutput

func (*Realm) ToRealmOutputWithContext 

func (i *Realm) ToRealmOutputWithContext(ctx context.Context) RealmOutput

type RealmArgs 

type RealmArgs struct {
	// Human readable description of the realm.
	Description pulumi.StringPtrInput
	// ETag of the resource.
	Etag pulumi.StringPtrInput
	// The labels associated with this realm. Each label is a key-value pair.
	Labels   pulumi.StringMapInput
	Location pulumi.StringInput
	// The resource name of the realm, in the following form: `projects/{project}/locations/{location}/realms/{realm}`. For example, `projects/my-project/locations/{location}/realms/my-realm`.
	Name    pulumi.StringPtrInput
	Project pulumi.StringInput
	RealmId pulumi.StringInput
	// Required. Time zone where all policies targeting this realm are evaluated. The value of this field must be from the IANA time zone database: https://www.iana.org/time-zones.
	TimeZone pulumi.StringPtrInput
}

The set of arguments for constructing a Realm resource.

func (RealmArgs) ElementType 

func (RealmArgs) ElementType() reflect.Type

type RealmInput 

type RealmInput interface {
	pulumi.Input

	ToRealmOutput() RealmOutput
	ToRealmOutputWithContext(ctx context.Context) RealmOutput
}

type RealmOutput 

type RealmOutput struct {
	*pulumi.OutputState
}

func (RealmOutput) ElementType 

func (RealmOutput) ElementType() reflect.Type

func (RealmOutput) ToRealmOutput 

func (o RealmOutput) ToRealmOutput() RealmOutput

func (RealmOutput) ToRealmOutputWithContext 

func (o RealmOutput) ToRealmOutputWithContext(ctx context.Context) RealmOutput

type RealmState 

type RealmState struct {
	// The creation time.
	CreateTime pulumi.StringPtrInput
	// Human readable description of the realm.
	Description pulumi.StringPtrInput
	// ETag of the resource.
	Etag pulumi.StringPtrInput
	// The labels associated with this realm. Each label is a key-value pair.
	Labels pulumi.StringMapInput
	// The resource name of the realm, in the following form: `projects/{project}/locations/{location}/realms/{realm}`. For example, `projects/my-project/locations/{location}/realms/my-realm`.
	Name pulumi.StringPtrInput
	// Required. Time zone where all policies targeting this realm are evaluated. The value of this field must be from the IANA time zone database: https://www.iana.org/time-zones.
	TimeZone pulumi.StringPtrInput
	// The last-modified time.
	UpdateTime pulumi.StringPtrInput
}

func (RealmState) ElementType 

func (RealmState) ElementType() reflect.Type

type Rule 

type Rule struct {
	// Required
	Action *string `pulumi:"action"`
	// Additional restrictions that must be met. All conditions must pass for the rule to match.
	Conditions []Condition `pulumi:"conditions"`
	// Human-readable description of the rule.
	Description *string `pulumi:"description"`
	// If one or more 'in' clauses are specified, the rule matches if the PRINCIPAL/AUTHORITY_SELECTOR is in at least one of these entries.
	In []string `pulumi:"in"`
	// The config returned to callers of tech.iam.IAM.CheckPolicy for any entries that match the LOG action.
	LogConfig []LogConfig `pulumi:"logConfig"`
	// If one or more 'not_in' clauses are specified, the rule matches if the PRINCIPAL/AUTHORITY_SELECTOR is in none of the entries. The format for in and not_in entries can be found at in the Local IAM documentation (see go/local-iam#features).
	NotIn []string `pulumi:"notIn"`
	// A permission is a string of form '..' (e.g., 'storage.buckets.list'). A value of '*' matches all permissions, and a verb part of '*' (e.g., 'storage.buckets.*') matches all verbs.
	Permissions []string `pulumi:"permissions"`
}

A rule to be applied in a Policy.

type RuleArgs 

type RuleArgs struct {
	// Required
	Action pulumi.StringPtrInput `pulumi:"action"`
	// Additional restrictions that must be met. All conditions must pass for the rule to match.
	Conditions ConditionArrayInput `pulumi:"conditions"`
	// Human-readable description of the rule.
	Description pulumi.StringPtrInput `pulumi:"description"`
	// If one or more 'in' clauses are specified, the rule matches if the PRINCIPAL/AUTHORITY_SELECTOR is in at least one of these entries.
	In pulumi.StringArrayInput `pulumi:"in"`
	// The config returned to callers of tech.iam.IAM.CheckPolicy for any entries that match the LOG action.
	LogConfig LogConfigArrayInput `pulumi:"logConfig"`
	// If one or more 'not_in' clauses are specified, the rule matches if the PRINCIPAL/AUTHORITY_SELECTOR is in none of the entries. The format for in and not_in entries can be found at in the Local IAM documentation (see go/local-iam#features).
	NotIn pulumi.StringArrayInput `pulumi:"notIn"`
	// A permission is a string of form '..' (e.g., 'storage.buckets.list'). A value of '*' matches all permissions, and a verb part of '*' (e.g., 'storage.buckets.*') matches all verbs.
	Permissions pulumi.StringArrayInput `pulumi:"permissions"`
}

A rule to be applied in a Policy.

func (RuleArgs) ElementType 

func (RuleArgs) ElementType() reflect.Type

func (RuleArgs) ToRuleOutput 

func (i RuleArgs) ToRuleOutput() RuleOutput

func (RuleArgs) ToRuleOutputWithContext 

func (i RuleArgs) ToRuleOutputWithContext(ctx context.Context) RuleOutput

type RuleArray 

type RuleArray []RuleInput

func (RuleArray) ElementType 

func (RuleArray) ElementType() reflect.Type

func (RuleArray) ToRuleArrayOutput 

func (i RuleArray) ToRuleArrayOutput() RuleArrayOutput

func (RuleArray) ToRuleArrayOutputWithContext 

func (i RuleArray) ToRuleArrayOutputWithContext(ctx context.Context) RuleArrayOutput

type RuleArrayInput 

type RuleArrayInput interface {
	pulumi.Input

	ToRuleArrayOutput() RuleArrayOutput
	ToRuleArrayOutputWithContext(context.Context) RuleArrayOutput
}

RuleArrayInput is an input type that accepts RuleArray and RuleArrayOutput values. You can construct a concrete instance of `RuleArrayInput` via: 

RuleArray{ RuleArgs{...} }

type RuleArrayOutput 

type RuleArrayOutput struct{ *pulumi.OutputState }

func (RuleArrayOutput) ElementType 

func (RuleArrayOutput) ElementType() reflect.Type

func (RuleArrayOutput) Index 

func (o RuleArrayOutput) Index(i pulumi.IntInput) RuleOutput

func (RuleArrayOutput) ToRuleArrayOutput 

func (o RuleArrayOutput) ToRuleArrayOutput() RuleArrayOutput

func (RuleArrayOutput) ToRuleArrayOutputWithContext 

func (o RuleArrayOutput) ToRuleArrayOutputWithContext(ctx context.Context) RuleArrayOutput

type RuleInput 

type RuleInput interface {
	pulumi.Input

	ToRuleOutput() RuleOutput
	ToRuleOutputWithContext(context.Context) RuleOutput
}

RuleInput is an input type that accepts RuleArgs and RuleOutput values. You can construct a concrete instance of `RuleInput` via: 

RuleArgs{...}

type RuleOutput 

type RuleOutput struct{ *pulumi.OutputState }

A rule to be applied in a Policy.

func (RuleOutput) Action 

func (o RuleOutput) Action() pulumi.StringPtrOutput

Required

func (RuleOutput) Conditions 

func (o RuleOutput) Conditions() ConditionArrayOutput

Additional restrictions that must be met. All conditions must pass for the rule to match.

func (RuleOutput) Description 

func (o RuleOutput) Description() pulumi.StringPtrOutput

Human-readable description of the rule.

func (RuleOutput) ElementType 

func (RuleOutput) ElementType() reflect.Type

func (RuleOutput) In 

func (o RuleOutput) In() pulumi.StringArrayOutput

If one or more 'in' clauses are specified, the rule matches if the PRINCIPAL/AUTHORITY_SELECTOR is in at least one of these entries.

func (RuleOutput) LogConfig 

func (o RuleOutput) LogConfig() LogConfigArrayOutput

The config returned to callers of tech.iam.IAM.CheckPolicy for any entries that match the LOG action.

func (RuleOutput) NotIn 

func (o RuleOutput) NotIn() pulumi.StringArrayOutput

If one or more 'not_in' clauses are specified, the rule matches if the PRINCIPAL/AUTHORITY_SELECTOR is in none of the entries. The format for in and not_in entries can be found at in the Local IAM documentation (see go/local-iam#features).

func (RuleOutput) Permissions 

func (o RuleOutput) Permissions() pulumi.StringArrayOutput

A permission is a string of form '..' (e.g., 'storage.buckets.list'). A value of '*' matches all permissions, and a verb part of '*' (e.g., 'storage.buckets.*') matches all verbs.

func (RuleOutput) ToRuleOutput 

func (o RuleOutput) ToRuleOutput() RuleOutput

func (RuleOutput) ToRuleOutputWithContext 

func (o RuleOutput) ToRuleOutputWithContext(ctx context.Context) RuleOutput

type RuleResponse 

type RuleResponse struct {
	// Required
	Action string `pulumi:"action"`
	// Additional restrictions that must be met. All conditions must pass for the rule to match.
	Conditions []ConditionResponse `pulumi:"conditions"`
	// Human-readable description of the rule.
	Description string `pulumi:"description"`
	// If one or more 'in' clauses are specified, the rule matches if the PRINCIPAL/AUTHORITY_SELECTOR is in at least one of these entries.
	In []string `pulumi:"in"`
	// The config returned to callers of tech.iam.IAM.CheckPolicy for any entries that match the LOG action.
	LogConfig []LogConfigResponse `pulumi:"logConfig"`
	// If one or more 'not_in' clauses are specified, the rule matches if the PRINCIPAL/AUTHORITY_SELECTOR is in none of the entries. The format for in and not_in entries can be found at in the Local IAM documentation (see go/local-iam#features).
	NotIn []string `pulumi:"notIn"`
	// A permission is a string of form '..' (e.g., 'storage.buckets.list'). A value of '*' matches all permissions, and a verb part of '*' (e.g., 'storage.buckets.*') matches all verbs.
	Permissions []string `pulumi:"permissions"`
}

A rule to be applied in a Policy.

type RuleResponseArgs 

type RuleResponseArgs struct {
	// Required
	Action pulumi.StringInput `pulumi:"action"`
	// Additional restrictions that must be met. All conditions must pass for the rule to match.
	Conditions ConditionResponseArrayInput `pulumi:"conditions"`
	// Human-readable description of the rule.
	Description pulumi.StringInput `pulumi:"description"`
	// If one or more 'in' clauses are specified, the rule matches if the PRINCIPAL/AUTHORITY_SELECTOR is in at least one of these entries.
	In pulumi.StringArrayInput `pulumi:"in"`
	// The config returned to callers of tech.iam.IAM.CheckPolicy for any entries that match the LOG action.
	LogConfig LogConfigResponseArrayInput `pulumi:"logConfig"`
	// If one or more 'not_in' clauses are specified, the rule matches if the PRINCIPAL/AUTHORITY_SELECTOR is in none of the entries. The format for in and not_in entries can be found at in the Local IAM documentation (see go/local-iam#features).
	NotIn pulumi.StringArrayInput `pulumi:"notIn"`
	// A permission is a string of form '..' (e.g., 'storage.buckets.list'). A value of '*' matches all permissions, and a verb part of '*' (e.g., 'storage.buckets.*') matches all verbs.
	Permissions pulumi.StringArrayInput `pulumi:"permissions"`
}

A rule to be applied in a Policy.

func (RuleResponseArgs) ElementType 

func (RuleResponseArgs) ElementType() reflect.Type

func (RuleResponseArgs) ToRuleResponseOutput 

func (i RuleResponseArgs) ToRuleResponseOutput() RuleResponseOutput

func (RuleResponseArgs) ToRuleResponseOutputWithContext 

func (i RuleResponseArgs) ToRuleResponseOutputWithContext(ctx context.Context) RuleResponseOutput

type RuleResponseArray 

type RuleResponseArray []RuleResponseInput

func (RuleResponseArray) ElementType 

func (RuleResponseArray) ElementType() reflect.Type

func (RuleResponseArray) ToRuleResponseArrayOutput 

func (i RuleResponseArray) ToRuleResponseArrayOutput() RuleResponseArrayOutput

func (RuleResponseArray) ToRuleResponseArrayOutputWithContext 

func (i RuleResponseArray) ToRuleResponseArrayOutputWithContext(ctx context.Context) RuleResponseArrayOutput

type RuleResponseArrayInput 

type RuleResponseArrayInput interface {
	pulumi.Input

	ToRuleResponseArrayOutput() RuleResponseArrayOutput
	ToRuleResponseArrayOutputWithContext(context.Context) RuleResponseArrayOutput
}

RuleResponseArrayInput is an input type that accepts RuleResponseArray and RuleResponseArrayOutput values. You can construct a concrete instance of `RuleResponseArrayInput` via: 

RuleResponseArray{ RuleResponseArgs{...} }

type RuleResponseArrayOutput 

type RuleResponseArrayOutput struct{ *pulumi.OutputState }

func (RuleResponseArrayOutput) ElementType 

func (RuleResponseArrayOutput) ElementType() reflect.Type

func (RuleResponseArrayOutput) Index 

func (o RuleResponseArrayOutput) Index(i pulumi.IntInput) RuleResponseOutput

func (RuleResponseArrayOutput) ToRuleResponseArrayOutput 

func (o RuleResponseArrayOutput) ToRuleResponseArrayOutput() RuleResponseArrayOutput

func (RuleResponseArrayOutput) ToRuleResponseArrayOutputWithContext 

func (o RuleResponseArrayOutput) ToRuleResponseArrayOutputWithContext(ctx context.Context) RuleResponseArrayOutput

type RuleResponseInput 

type RuleResponseInput interface {
	pulumi.Input

	ToRuleResponseOutput() RuleResponseOutput
	ToRuleResponseOutputWithContext(context.Context) RuleResponseOutput
}

RuleResponseInput is an input type that accepts RuleResponseArgs and RuleResponseOutput values. You can construct a concrete instance of `RuleResponseInput` via: 

RuleResponseArgs{...}

type RuleResponseOutput 

type RuleResponseOutput struct{ *pulumi.OutputState }

A rule to be applied in a Policy.

func (RuleResponseOutput) Action 

func (o RuleResponseOutput) Action() pulumi.StringOutput

Required

func (RuleResponseOutput) Conditions 

func (o RuleResponseOutput) Conditions() ConditionResponseArrayOutput

Additional restrictions that must be met. All conditions must pass for the rule to match.

func (RuleResponseOutput) Description 

func (o RuleResponseOutput) Description() pulumi.StringOutput

Human-readable description of the rule.

func (RuleResponseOutput) ElementType 

func (RuleResponseOutput) ElementType() reflect.Type

func (RuleResponseOutput) In 

func (o RuleResponseOutput) In() pulumi.StringArrayOutput

If one or more 'in' clauses are specified, the rule matches if the PRINCIPAL/AUTHORITY_SELECTOR is in at least one of these entries.

func (RuleResponseOutput) LogConfig 

func (o RuleResponseOutput) LogConfig() LogConfigResponseArrayOutput

The config returned to callers of tech.iam.IAM.CheckPolicy for any entries that match the LOG action.

func (RuleResponseOutput) NotIn 

func (o RuleResponseOutput) NotIn() pulumi.StringArrayOutput

If one or more 'not_in' clauses are specified, the rule matches if the PRINCIPAL/AUTHORITY_SELECTOR is in none of the entries. The format for in and not_in entries can be found at in the Local IAM documentation (see go/local-iam#features).

func (RuleResponseOutput) Permissions 

func (o RuleResponseOutput) Permissions() pulumi.StringArrayOutput

A permission is a string of form '..' (e.g., 'storage.buckets.list'). A value of '*' matches all permissions, and a verb part of '*' (e.g., 'storage.buckets.*') matches all verbs.

func (RuleResponseOutput) ToRuleResponseOutput 

func (o RuleResponseOutput) ToRuleResponseOutput() RuleResponseOutput

func (RuleResponseOutput) ToRuleResponseOutputWithContext 

func (o RuleResponseOutput) ToRuleResponseOutputWithContext(ctx context.Context) RuleResponseOutput

type ScalingConfig 

type ScalingConfig struct {
	// Required. Agones fleet autoscaler spec. Example spec: https://agones.dev/site/docs/reference/fleetautoscaler/
	FleetAutoscalerSpec *string `pulumi:"fleetAutoscalerSpec"`
	// Required. The name of the Scaling Config
	Name *string `pulumi:"name"`
	// The schedules to which this Scaling Config applies.
	Schedules []Schedule `pulumi:"schedules"`
	// Labels used to identify the game server clusters to which this Agones scaling config applies. A game server cluster is subject to this Agones scaling config if its labels match any of the selector entries.
	Selectors []LabelSelector `pulumi:"selectors"`
}

Autoscaling config for an Agones fleet.

type ScalingConfigArgs 

type ScalingConfigArgs struct {
	// Required. Agones fleet autoscaler spec. Example spec: https://agones.dev/site/docs/reference/fleetautoscaler/
	FleetAutoscalerSpec pulumi.StringPtrInput `pulumi:"fleetAutoscalerSpec"`
	// Required. The name of the Scaling Config
	Name pulumi.StringPtrInput `pulumi:"name"`
	// The schedules to which this Scaling Config applies.
	Schedules ScheduleArrayInput `pulumi:"schedules"`
	// Labels used to identify the game server clusters to which this Agones scaling config applies. A game server cluster is subject to this Agones scaling config if its labels match any of the selector entries.
	Selectors LabelSelectorArrayInput `pulumi:"selectors"`
}

Autoscaling config for an Agones fleet.

func (ScalingConfigArgs) ElementType 

func (ScalingConfigArgs) ElementType() reflect.Type

func (ScalingConfigArgs) ToScalingConfigOutput 

func (i ScalingConfigArgs) ToScalingConfigOutput() ScalingConfigOutput

func (ScalingConfigArgs) ToScalingConfigOutputWithContext 

func (i ScalingConfigArgs) ToScalingConfigOutputWithContext(ctx context.Context) ScalingConfigOutput

type ScalingConfigArray 

type ScalingConfigArray []ScalingConfigInput

func (ScalingConfigArray) ElementType 

func (ScalingConfigArray) ElementType() reflect.Type

func (ScalingConfigArray) ToScalingConfigArrayOutput 

func (i ScalingConfigArray) ToScalingConfigArrayOutput() ScalingConfigArrayOutput

func (ScalingConfigArray) ToScalingConfigArrayOutputWithContext 

func (i ScalingConfigArray) ToScalingConfigArrayOutputWithContext(ctx context.Context) ScalingConfigArrayOutput

type ScalingConfigArrayInput 

type ScalingConfigArrayInput interface {
	pulumi.Input

	ToScalingConfigArrayOutput() ScalingConfigArrayOutput
	ToScalingConfigArrayOutputWithContext(context.Context) ScalingConfigArrayOutput
}

ScalingConfigArrayInput is an input type that accepts ScalingConfigArray and ScalingConfigArrayOutput values. You can construct a concrete instance of `ScalingConfigArrayInput` via: 

ScalingConfigArray{ ScalingConfigArgs{...} }

type ScalingConfigArrayOutput 

type ScalingConfigArrayOutput struct{ *pulumi.OutputState }

func (ScalingConfigArrayOutput) ElementType 

func (ScalingConfigArrayOutput) ElementType() reflect.Type

func (ScalingConfigArrayOutput) Index 

func (o ScalingConfigArrayOutput) Index(i pulumi.IntInput) ScalingConfigOutput

func (ScalingConfigArrayOutput) ToScalingConfigArrayOutput 

func (o ScalingConfigArrayOutput) ToScalingConfigArrayOutput() ScalingConfigArrayOutput

func (ScalingConfigArrayOutput) ToScalingConfigArrayOutputWithContext 

func (o ScalingConfigArrayOutput) ToScalingConfigArrayOutputWithContext(ctx context.Context) ScalingConfigArrayOutput

type ScalingConfigInput 

type ScalingConfigInput interface {
	pulumi.Input

	ToScalingConfigOutput() ScalingConfigOutput
	ToScalingConfigOutputWithContext(context.Context) ScalingConfigOutput
}

ScalingConfigInput is an input type that accepts ScalingConfigArgs and ScalingConfigOutput values. You can construct a concrete instance of `ScalingConfigInput` via: 

ScalingConfigArgs{...}

type ScalingConfigOutput 

type ScalingConfigOutput struct{ *pulumi.OutputState }

Autoscaling config for an Agones fleet.

func (ScalingConfigOutput) ElementType 

func (ScalingConfigOutput) ElementType() reflect.Type

func (ScalingConfigOutput) FleetAutoscalerSpec 

func (o ScalingConfigOutput) FleetAutoscalerSpec() pulumi.StringPtrOutput

Required. Agones fleet autoscaler spec. Example spec: https://agones.dev/site/docs/reference/fleetautoscaler/

func (ScalingConfigOutput) Name 

func (o ScalingConfigOutput) Name() pulumi.StringPtrOutput

Required. The name of the Scaling Config

func (ScalingConfigOutput) Schedules 

func (o ScalingConfigOutput) Schedules() ScheduleArrayOutput

The schedules to which this Scaling Config applies.

func (ScalingConfigOutput) Selectors 

func (o ScalingConfigOutput) Selectors() LabelSelectorArrayOutput

Labels used to identify the game server clusters to which this Agones scaling config applies. A game server cluster is subject to this Agones scaling config if its labels match any of the selector entries.

func (ScalingConfigOutput) ToScalingConfigOutput 

func (o ScalingConfigOutput) ToScalingConfigOutput() ScalingConfigOutput

func (ScalingConfigOutput) ToScalingConfigOutputWithContext 

func (o ScalingConfigOutput) ToScalingConfigOutputWithContext(ctx context.Context) ScalingConfigOutput

type ScalingConfigResponse 

type ScalingConfigResponse struct {
	// Required. Agones fleet autoscaler spec. Example spec: https://agones.dev/site/docs/reference/fleetautoscaler/
	FleetAutoscalerSpec string `pulumi:"fleetAutoscalerSpec"`
	// Required. The name of the Scaling Config
	Name string `pulumi:"name"`
	// The schedules to which this Scaling Config applies.
	Schedules []ScheduleResponse `pulumi:"schedules"`
	// Labels used to identify the game server clusters to which this Agones scaling config applies. A game server cluster is subject to this Agones scaling config if its labels match any of the selector entries.
	Selectors []LabelSelectorResponse `pulumi:"selectors"`
}

Autoscaling config for an Agones fleet.

type ScalingConfigResponseArgs 

type ScalingConfigResponseArgs struct {
	// Required. Agones fleet autoscaler spec. Example spec: https://agones.dev/site/docs/reference/fleetautoscaler/
	FleetAutoscalerSpec pulumi.StringInput `pulumi:"fleetAutoscalerSpec"`
	// Required. The name of the Scaling Config
	Name pulumi.StringInput `pulumi:"name"`
	// The schedules to which this Scaling Config applies.
	Schedules ScheduleResponseArrayInput `pulumi:"schedules"`
	// Labels used to identify the game server clusters to which this Agones scaling config applies. A game server cluster is subject to this Agones scaling config if its labels match any of the selector entries.
	Selectors LabelSelectorResponseArrayInput `pulumi:"selectors"`
}

Autoscaling config for an Agones fleet.

func (ScalingConfigResponseArgs) ElementType 

func (ScalingConfigResponseArgs) ElementType() reflect.Type

func (ScalingConfigResponseArgs) ToScalingConfigResponseOutput 

func (i ScalingConfigResponseArgs) ToScalingConfigResponseOutput() ScalingConfigResponseOutput

func (ScalingConfigResponseArgs) ToScalingConfigResponseOutputWithContext 

func (i ScalingConfigResponseArgs) ToScalingConfigResponseOutputWithContext(ctx context.Context) ScalingConfigResponseOutput

type ScalingConfigResponseArray 

type ScalingConfigResponseArray []ScalingConfigResponseInput

func (ScalingConfigResponseArray) ElementType 

func (ScalingConfigResponseArray) ElementType() reflect.Type

func (ScalingConfigResponseArray) ToScalingConfigResponseArrayOutput 

func (i ScalingConfigResponseArray) ToScalingConfigResponseArrayOutput() ScalingConfigResponseArrayOutput

func (ScalingConfigResponseArray) ToScalingConfigResponseArrayOutputWithContext 

func (i ScalingConfigResponseArray) ToScalingConfigResponseArrayOutputWithContext(ctx context.Context) ScalingConfigResponseArrayOutput

type ScalingConfigResponseArrayInput 

type ScalingConfigResponseArrayInput interface {
	pulumi.Input

	ToScalingConfigResponseArrayOutput() ScalingConfigResponseArrayOutput
	ToScalingConfigResponseArrayOutputWithContext(context.Context) ScalingConfigResponseArrayOutput
}

ScalingConfigResponseArrayInput is an input type that accepts ScalingConfigResponseArray and ScalingConfigResponseArrayOutput values. You can construct a concrete instance of `ScalingConfigResponseArrayInput` via: 

ScalingConfigResponseArray{ ScalingConfigResponseArgs{...} }

type ScalingConfigResponseArrayOutput 

type ScalingConfigResponseArrayOutput struct{ *pulumi.OutputState }

func (ScalingConfigResponseArrayOutput) ElementType 

func (ScalingConfigResponseArrayOutput) ElementType() reflect.Type

func (ScalingConfigResponseArrayOutput) Index 

func (o ScalingConfigResponseArrayOutput) Index(i pulumi.IntInput) ScalingConfigResponseOutput

func (ScalingConfigResponseArrayOutput) ToScalingConfigResponseArrayOutput 

func (o ScalingConfigResponseArrayOutput) ToScalingConfigResponseArrayOutput() ScalingConfigResponseArrayOutput

func (ScalingConfigResponseArrayOutput) ToScalingConfigResponseArrayOutputWithContext 

func (o ScalingConfigResponseArrayOutput) ToScalingConfigResponseArrayOutputWithContext(ctx context.Context) ScalingConfigResponseArrayOutput

type ScalingConfigResponseInput 

type ScalingConfigResponseInput interface {
	pulumi.Input

	ToScalingConfigResponseOutput() ScalingConfigResponseOutput
	ToScalingConfigResponseOutputWithContext(context.Context) ScalingConfigResponseOutput
}

ScalingConfigResponseInput is an input type that accepts ScalingConfigResponseArgs and ScalingConfigResponseOutput values. You can construct a concrete instance of `ScalingConfigResponseInput` via: 

ScalingConfigResponseArgs{...}

type ScalingConfigResponseOutput 

type ScalingConfigResponseOutput struct{ *pulumi.OutputState }

Autoscaling config for an Agones fleet.

func (ScalingConfigResponseOutput) ElementType 

func (ScalingConfigResponseOutput) ElementType() reflect.Type

func (ScalingConfigResponseOutput) FleetAutoscalerSpec 

func (o ScalingConfigResponseOutput) FleetAutoscalerSpec() pulumi.StringOutput

Required. Agones fleet autoscaler spec. Example spec: https://agones.dev/site/docs/reference/fleetautoscaler/

func (ScalingConfigResponseOutput) Name 

func (o ScalingConfigResponseOutput) Name() pulumi.StringOutput

Required. The name of the Scaling Config

func (ScalingConfigResponseOutput) Schedules 

func (o ScalingConfigResponseOutput) Schedules() ScheduleResponseArrayOutput

The schedules to which this Scaling Config applies.

func (ScalingConfigResponseOutput) Selectors 

func (o ScalingConfigResponseOutput) Selectors() LabelSelectorResponseArrayOutput

Labels used to identify the game server clusters to which this Agones scaling config applies. A game server cluster is subject to this Agones scaling config if its labels match any of the selector entries.

func (ScalingConfigResponseOutput) ToScalingConfigResponseOutput 

func (o ScalingConfigResponseOutput) ToScalingConfigResponseOutput() ScalingConfigResponseOutput

func (ScalingConfigResponseOutput) ToScalingConfigResponseOutputWithContext 

func (o ScalingConfigResponseOutput) ToScalingConfigResponseOutputWithContext(ctx context.Context) ScalingConfigResponseOutput

type Schedule 

type Schedule struct {
	// The duration for the cron job event. The duration of the event is effective after the cron job's start time.
	CronJobDuration *string `pulumi:"cronJobDuration"`
	// The cron definition of the scheduled event. See https://en.wikipedia.org/wiki/Cron. Cron spec specifies the local time as defined by the realm.
	CronSpec *string `pulumi:"cronSpec"`
	// The end time of the event.
	EndTime *string `pulumi:"endTime"`
	// The start time of the event.
	StartTime *string `pulumi:"startTime"`
}

The schedule of a recurring or one time event. The event's time span is specified by start_time and end_time. If the scheduled event's timespan is larger than the cron_spec + cron_job_duration, the event will be recurring. If only cron_spec + cron_job_duration are specified, the event is effective starting at the local time specified by cron_spec, and is recurring. start_time|-------[cron job]-------[cron job]-------[cron job]---|end_time cron job: cron spec start time + duration

type ScheduleArgs 

type ScheduleArgs struct {
	// The duration for the cron job event. The duration of the event is effective after the cron job's start time.
	CronJobDuration pulumi.StringPtrInput `pulumi:"cronJobDuration"`
	// The cron definition of the scheduled event. See https://en.wikipedia.org/wiki/Cron. Cron spec specifies the local time as defined by the realm.
	CronSpec pulumi.StringPtrInput `pulumi:"cronSpec"`
	// The end time of the event.
	EndTime pulumi.StringPtrInput `pulumi:"endTime"`
	// The start time of the event.
	StartTime pulumi.StringPtrInput `pulumi:"startTime"`
}

The schedule of a recurring or one time event. The event's time span is specified by start_time and end_time. If the scheduled event's timespan is larger than the cron_spec + cron_job_duration, the event will be recurring. If only cron_spec + cron_job_duration are specified, the event is effective starting at the local time specified by cron_spec, and is recurring. start_time|-------[cron job]-------[cron job]-------[cron job]---|end_time cron job: cron spec start time + duration

func (ScheduleArgs) ElementType 

func (ScheduleArgs) ElementType() reflect.Type

func (ScheduleArgs) ToScheduleOutput 

func (i ScheduleArgs) ToScheduleOutput() ScheduleOutput

func (ScheduleArgs) ToScheduleOutputWithContext 

func (i ScheduleArgs) ToScheduleOutputWithContext(ctx context.Context) ScheduleOutput

type ScheduleArray 

type ScheduleArray []ScheduleInput

func (ScheduleArray) ElementType 

func (ScheduleArray) ElementType() reflect.Type

func (ScheduleArray) ToScheduleArrayOutput 

func (i ScheduleArray) ToScheduleArrayOutput() ScheduleArrayOutput

func (ScheduleArray) ToScheduleArrayOutputWithContext 

func (i ScheduleArray) ToScheduleArrayOutputWithContext(ctx context.Context) ScheduleArrayOutput

type ScheduleArrayInput 

type ScheduleArrayInput interface {
	pulumi.Input

	ToScheduleArrayOutput() ScheduleArrayOutput
	ToScheduleArrayOutputWithContext(context.Context) ScheduleArrayOutput
}

ScheduleArrayInput is an input type that accepts ScheduleArray and ScheduleArrayOutput values. You can construct a concrete instance of `ScheduleArrayInput` via: 

ScheduleArray{ ScheduleArgs{...} }

type ScheduleArrayOutput 

type ScheduleArrayOutput struct{ *pulumi.OutputState }

func (ScheduleArrayOutput) ElementType 

func (ScheduleArrayOutput) ElementType() reflect.Type

func (ScheduleArrayOutput) Index 

func (o ScheduleArrayOutput) Index(i pulumi.IntInput) ScheduleOutput

func (ScheduleArrayOutput) ToScheduleArrayOutput 

func (o ScheduleArrayOutput) ToScheduleArrayOutput() ScheduleArrayOutput

func (ScheduleArrayOutput) ToScheduleArrayOutputWithContext 

func (o ScheduleArrayOutput) ToScheduleArrayOutputWithContext(ctx context.Context) ScheduleArrayOutput

type ScheduleInput 

type ScheduleInput interface {
	pulumi.Input

	ToScheduleOutput() ScheduleOutput
	ToScheduleOutputWithContext(context.Context) ScheduleOutput
}

ScheduleInput is an input type that accepts ScheduleArgs and ScheduleOutput values. You can construct a concrete instance of `ScheduleInput` via: 

ScheduleArgs{...}

type ScheduleOutput 

type ScheduleOutput struct{ *pulumi.OutputState }

The schedule of a recurring or one time event. The event's time span is specified by start_time and end_time. If the scheduled event's timespan is larger than the cron_spec + cron_job_duration, the event will be recurring. If only cron_spec + cron_job_duration are specified, the event is effective starting at the local time specified by cron_spec, and is recurring. start_time|-------[cron job]-------[cron job]-------[cron job]---|end_time cron job: cron spec start time + duration

func (ScheduleOutput) CronJobDuration 

func (o ScheduleOutput) CronJobDuration() pulumi.StringPtrOutput

The duration for the cron job event. The duration of the event is effective after the cron job's start time.

func (ScheduleOutput) CronSpec 

func (o ScheduleOutput) CronSpec() pulumi.StringPtrOutput

The cron definition of the scheduled event. See https://en.wikipedia.org/wiki/Cron. Cron spec specifies the local time as defined by the realm.

func (ScheduleOutput) ElementType 

func (ScheduleOutput) ElementType() reflect.Type

func (ScheduleOutput) EndTime 

func (o ScheduleOutput) EndTime() pulumi.StringPtrOutput

The end time of the event.

func (ScheduleOutput) StartTime 

func (o ScheduleOutput) StartTime() pulumi.StringPtrOutput

The start time of the event.

func (ScheduleOutput) ToScheduleOutput 

func (o ScheduleOutput) ToScheduleOutput() ScheduleOutput

func (ScheduleOutput) ToScheduleOutputWithContext 

func (o ScheduleOutput) ToScheduleOutputWithContext(ctx context.Context) ScheduleOutput

type ScheduleResponse 

type ScheduleResponse struct {
	// The duration for the cron job event. The duration of the event is effective after the cron job's start time.
	CronJobDuration string `pulumi:"cronJobDuration"`
	// The cron definition of the scheduled event. See https://en.wikipedia.org/wiki/Cron. Cron spec specifies the local time as defined by the realm.
	CronSpec string `pulumi:"cronSpec"`
	// The end time of the event.
	EndTime string `pulumi:"endTime"`
	// The start time of the event.
	StartTime string `pulumi:"startTime"`
}

The schedule of a recurring or one time event. The event's time span is specified by start_time and end_time. If the scheduled event's timespan is larger than the cron_spec + cron_job_duration, the event will be recurring. If only cron_spec + cron_job_duration are specified, the event is effective starting at the local time specified by cron_spec, and is recurring. start_time|-------[cron job]-------[cron job]-------[cron job]---|end_time cron job: cron spec start time + duration

type ScheduleResponseArgs 

type ScheduleResponseArgs struct {
	// The duration for the cron job event. The duration of the event is effective after the cron job's start time.
	CronJobDuration pulumi.StringInput `pulumi:"cronJobDuration"`
	// The cron definition of the scheduled event. See https://en.wikipedia.org/wiki/Cron. Cron spec specifies the local time as defined by the realm.
	CronSpec pulumi.StringInput `pulumi:"cronSpec"`
	// The end time of the event.
	EndTime pulumi.StringInput `pulumi:"endTime"`
	// The start time of the event.
	StartTime pulumi.StringInput `pulumi:"startTime"`
}

The schedule of a recurring or one time event. The event's time span is specified by start_time and end_time. If the scheduled event's timespan is larger than the cron_spec + cron_job_duration, the event will be recurring. If only cron_spec + cron_job_duration are specified, the event is effective starting at the local time specified by cron_spec, and is recurring. start_time|-------[cron job]-------[cron job]-------[cron job]---|end_time cron job: cron spec start time + duration

func (ScheduleResponseArgs) ElementType 

func (ScheduleResponseArgs) ElementType() reflect.Type

func (ScheduleResponseArgs) ToScheduleResponseOutput 

func (i ScheduleResponseArgs) ToScheduleResponseOutput() ScheduleResponseOutput

func (ScheduleResponseArgs) ToScheduleResponseOutputWithContext 

func (i ScheduleResponseArgs) ToScheduleResponseOutputWithContext(ctx context.Context) ScheduleResponseOutput

type ScheduleResponseArray 

type ScheduleResponseArray []ScheduleResponseInput

func (ScheduleResponseArray) ElementType 

func (ScheduleResponseArray) ElementType() reflect.Type

func (ScheduleResponseArray) ToScheduleResponseArrayOutput 

func (i ScheduleResponseArray) ToScheduleResponseArrayOutput() ScheduleResponseArrayOutput

func (ScheduleResponseArray) ToScheduleResponseArrayOutputWithContext 

func (i ScheduleResponseArray) ToScheduleResponseArrayOutputWithContext(ctx context.Context) ScheduleResponseArrayOutput

type ScheduleResponseArrayInput 

type ScheduleResponseArrayInput interface {
	pulumi.Input

	ToScheduleResponseArrayOutput() ScheduleResponseArrayOutput
	ToScheduleResponseArrayOutputWithContext(context.Context) ScheduleResponseArrayOutput
}

ScheduleResponseArrayInput is an input type that accepts ScheduleResponseArray and ScheduleResponseArrayOutput values. You can construct a concrete instance of `ScheduleResponseArrayInput` via: 

ScheduleResponseArray{ ScheduleResponseArgs{...} }

type ScheduleResponseArrayOutput 

type ScheduleResponseArrayOutput struct{ *pulumi.OutputState }

func (ScheduleResponseArrayOutput) ElementType 

func (ScheduleResponseArrayOutput) ElementType() reflect.Type

func (ScheduleResponseArrayOutput) Index 

func (o ScheduleResponseArrayOutput) Index(i pulumi.IntInput) ScheduleResponseOutput

func (ScheduleResponseArrayOutput) ToScheduleResponseArrayOutput 

func (o ScheduleResponseArrayOutput) ToScheduleResponseArrayOutput() ScheduleResponseArrayOutput

func (ScheduleResponseArrayOutput) ToScheduleResponseArrayOutputWithContext 

func (o ScheduleResponseArrayOutput) ToScheduleResponseArrayOutputWithContext(ctx context.Context) ScheduleResponseArrayOutput

type ScheduleResponseInput 

type ScheduleResponseInput interface {
	pulumi.Input

	ToScheduleResponseOutput() ScheduleResponseOutput
	ToScheduleResponseOutputWithContext(context.Context) ScheduleResponseOutput
}

ScheduleResponseInput is an input type that accepts ScheduleResponseArgs and ScheduleResponseOutput values. You can construct a concrete instance of `ScheduleResponseInput` via: 

ScheduleResponseArgs{...}

type ScheduleResponseOutput 

type ScheduleResponseOutput struct{ *pulumi.OutputState }

The schedule of a recurring or one time event. The event's time span is specified by start_time and end_time. If the scheduled event's timespan is larger than the cron_spec + cron_job_duration, the event will be recurring. If only cron_spec + cron_job_duration are specified, the event is effective starting at the local time specified by cron_spec, and is recurring. start_time|-------[cron job]-------[cron job]-------[cron job]---|end_time cron job: cron spec start time + duration

func (ScheduleResponseOutput) CronJobDuration 

func (o ScheduleResponseOutput) CronJobDuration() pulumi.StringOutput

The duration for the cron job event. The duration of the event is effective after the cron job's start time.

func (ScheduleResponseOutput) CronSpec 

func (o ScheduleResponseOutput) CronSpec() pulumi.StringOutput

The cron definition of the scheduled event. See https://en.wikipedia.org/wiki/Cron. Cron spec specifies the local time as defined by the realm.

func (ScheduleResponseOutput) ElementType 

func (ScheduleResponseOutput) ElementType() reflect.Type

func (ScheduleResponseOutput) EndTime 

func (o ScheduleResponseOutput) EndTime() pulumi.StringOutput

The end time of the event.

func (ScheduleResponseOutput) StartTime 

func (o ScheduleResponseOutput) StartTime() pulumi.StringOutput

The start time of the event.

func (ScheduleResponseOutput) ToScheduleResponseOutput 

func (o ScheduleResponseOutput) ToScheduleResponseOutput() ScheduleResponseOutput

func (ScheduleResponseOutput) ToScheduleResponseOutputWithContext 

func (o ScheduleResponseOutput) ToScheduleResponseOutputWithContext(ctx context.Context) ScheduleResponseOutput

Source Files

View all Source files

Jump to

Keyboard shortcuts

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