// Code generated by crd2pulumi DO NOT EDIT.
// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***

package v1alpha1

import (
	"context"
	"reflect"

	"antoine-roux.tk/projects/go/pulumi-library/crds/kubernetes/internal"
	v1 "github.com/pulumi/pulumi-kubernetes/sdk/v4/go/kubernetes/meta/v1"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumix"
)

var _ = internal.GetEnvOrDefault

// API defines an HTTP interface that is exposed to external clients. It specifies the supported versions
// and provides instructions for accessing its documentation. Once instantiated, an API object is associated
// with an Ingress, IngressRoute, or HTTPRoute resource, enabling the exposure of the described API to the outside world.
type APIType struct {
	ApiVersion *string        `pulumi:"apiVersion"`
	Kind       *string        `pulumi:"kind"`
	Metadata   *v1.ObjectMeta `pulumi:"metadata"`
	// APISpec describes the API.
	Spec *APISpec `pulumi:"spec"`
	// The current status of this API.
	Status *APIStatus `pulumi:"status"`
}

// APIAccess defines who can access to a set of APIs.
type APIAccessType struct {
	ApiVersion *string        `pulumi:"apiVersion"`
	Kind       *string        `pulumi:"kind"`
	Metadata   *v1.ObjectMeta `pulumi:"metadata"`
	// The desired behavior of this APIAccess.
	Spec *APIAccessSpec `pulumi:"spec"`
	// The current status of this APIAccess.
	Status *APIAccessStatus `pulumi:"status"`
}

type APIAccessMetadata struct {
}

// The desired behavior of this APIAccess.
type APIAccessSpec struct {
	// APISelector selects the APIs that will be accessible to the configured audience.
	// Multiple APIAccesses can select the same set of APIs.
	// This field is optional and follows standard label selector semantics.
	// An empty APISelector matches any API.
	ApiSelector *APIAccessSpecApiSelector `pulumi:"apiSelector"`
	// APIs defines a set of APIs that will be accessible to the configured audience.
	// Multiple APIAccesses can select the same APIs.
	// When combined with APISelector, this set of APIs is appended to the matching APIs.
	Apis []APIAccessSpecApis `pulumi:"apis"`
	// Everyone indicates that all users will have access to the selected APIs.
	Everyone *bool `pulumi:"everyone"`
	// Groups are the consumer groups that will gain access to the selected APIs.
	Groups []string `pulumi:"groups"`
	// OperationFilter specifies the allowed operations on APIs and APIVersions.
	// If not set, all operations are available.
	// An empty OperationFilter prohibits all operations.
	OperationFilter *APIAccessSpecOperationFilter `pulumi:"operationFilter"`
}

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

	ToAPIAccessSpecOutput() APIAccessSpecOutput
	ToAPIAccessSpecOutputWithContext(context.Context) APIAccessSpecOutput
}

// The desired behavior of this APIAccess.
type APIAccessSpecArgs struct {
	// APISelector selects the APIs that will be accessible to the configured audience.
	// Multiple APIAccesses can select the same set of APIs.
	// This field is optional and follows standard label selector semantics.
	// An empty APISelector matches any API.
	ApiSelector APIAccessSpecApiSelectorPtrInput `pulumi:"apiSelector"`
	// APIs defines a set of APIs that will be accessible to the configured audience.
	// Multiple APIAccesses can select the same APIs.
	// When combined with APISelector, this set of APIs is appended to the matching APIs.
	Apis APIAccessSpecApisArrayInput `pulumi:"apis"`
	// Everyone indicates that all users will have access to the selected APIs.
	Everyone pulumi.BoolPtrInput `pulumi:"everyone"`
	// Groups are the consumer groups that will gain access to the selected APIs.
	Groups pulumi.StringArrayInput `pulumi:"groups"`
	// OperationFilter specifies the allowed operations on APIs and APIVersions.
	// If not set, all operations are available.
	// An empty OperationFilter prohibits all operations.
	OperationFilter APIAccessSpecOperationFilterPtrInput `pulumi:"operationFilter"`
}

func (APIAccessSpecArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APIAccessSpec)(nil)).Elem()
}

func (i APIAccessSpecArgs) ToAPIAccessSpecOutput() APIAccessSpecOutput {
	return i.ToAPIAccessSpecOutputWithContext(context.Background())
}

func (i APIAccessSpecArgs) ToAPIAccessSpecOutputWithContext(ctx context.Context) APIAccessSpecOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIAccessSpecOutput)
}

func (i APIAccessSpecArgs) ToOutput(ctx context.Context) pulumix.Output[APIAccessSpec] {
	return pulumix.Output[APIAccessSpec]{
		OutputState: i.ToAPIAccessSpecOutputWithContext(ctx).OutputState,
	}
}

func (i APIAccessSpecArgs) ToAPIAccessSpecPtrOutput() APIAccessSpecPtrOutput {
	return i.ToAPIAccessSpecPtrOutputWithContext(context.Background())
}

func (i APIAccessSpecArgs) ToAPIAccessSpecPtrOutputWithContext(ctx context.Context) APIAccessSpecPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIAccessSpecOutput).ToAPIAccessSpecPtrOutputWithContext(ctx)
}

// APIAccessSpecPtrInput is an input type that accepts APIAccessSpecArgs, APIAccessSpecPtr and APIAccessSpecPtrOutput values.
// You can construct a concrete instance of `APIAccessSpecPtrInput` via:
//
//	        APIAccessSpecArgs{...}
//
//	or:
//
//	        nil
type APIAccessSpecPtrInput interface {
	pulumi.Input

	ToAPIAccessSpecPtrOutput() APIAccessSpecPtrOutput
	ToAPIAccessSpecPtrOutputWithContext(context.Context) APIAccessSpecPtrOutput
}

type apiaccessSpecPtrType APIAccessSpecArgs

func APIAccessSpecPtr(v *APIAccessSpecArgs) APIAccessSpecPtrInput {
	return (*apiaccessSpecPtrType)(v)
}

func (*apiaccessSpecPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**APIAccessSpec)(nil)).Elem()
}

func (i *apiaccessSpecPtrType) ToAPIAccessSpecPtrOutput() APIAccessSpecPtrOutput {
	return i.ToAPIAccessSpecPtrOutputWithContext(context.Background())
}

func (i *apiaccessSpecPtrType) ToAPIAccessSpecPtrOutputWithContext(ctx context.Context) APIAccessSpecPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIAccessSpecPtrOutput)
}

func (i *apiaccessSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*APIAccessSpec] {
	return pulumix.Output[*APIAccessSpec]{
		OutputState: i.ToAPIAccessSpecPtrOutputWithContext(ctx).OutputState,
	}
}

// The desired behavior of this APIAccess.
type APIAccessSpecOutput struct{ *pulumi.OutputState }

func (APIAccessSpecOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APIAccessSpec)(nil)).Elem()
}

func (o APIAccessSpecOutput) ToAPIAccessSpecOutput() APIAccessSpecOutput {
	return o
}

func (o APIAccessSpecOutput) ToAPIAccessSpecOutputWithContext(ctx context.Context) APIAccessSpecOutput {
	return o
}

func (o APIAccessSpecOutput) ToAPIAccessSpecPtrOutput() APIAccessSpecPtrOutput {
	return o.ToAPIAccessSpecPtrOutputWithContext(context.Background())
}

func (o APIAccessSpecOutput) ToAPIAccessSpecPtrOutputWithContext(ctx context.Context) APIAccessSpecPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v APIAccessSpec) *APIAccessSpec {
		return &v
	}).(APIAccessSpecPtrOutput)
}

func (o APIAccessSpecOutput) ToOutput(ctx context.Context) pulumix.Output[APIAccessSpec] {
	return pulumix.Output[APIAccessSpec]{
		OutputState: o.OutputState,
	}
}

// APISelector selects the APIs that will be accessible to the configured audience.
// Multiple APIAccesses can select the same set of APIs.
// This field is optional and follows standard label selector semantics.
// An empty APISelector matches any API.
func (o APIAccessSpecOutput) ApiSelector() APIAccessSpecApiSelectorPtrOutput {
	return o.ApplyT(func(v APIAccessSpec) *APIAccessSpecApiSelector { return v.ApiSelector }).(APIAccessSpecApiSelectorPtrOutput)
}

// APIs defines a set of APIs that will be accessible to the configured audience.
// Multiple APIAccesses can select the same APIs.
// When combined with APISelector, this set of APIs is appended to the matching APIs.
func (o APIAccessSpecOutput) Apis() APIAccessSpecApisArrayOutput {
	return o.ApplyT(func(v APIAccessSpec) []APIAccessSpecApis { return v.Apis }).(APIAccessSpecApisArrayOutput)
}

// Everyone indicates that all users will have access to the selected APIs.
func (o APIAccessSpecOutput) Everyone() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v APIAccessSpec) *bool { return v.Everyone }).(pulumi.BoolPtrOutput)
}

// Groups are the consumer groups that will gain access to the selected APIs.
func (o APIAccessSpecOutput) Groups() pulumi.StringArrayOutput {
	return o.ApplyT(func(v APIAccessSpec) []string { return v.Groups }).(pulumi.StringArrayOutput)
}

// OperationFilter specifies the allowed operations on APIs and APIVersions.
// If not set, all operations are available.
// An empty OperationFilter prohibits all operations.
func (o APIAccessSpecOutput) OperationFilter() APIAccessSpecOperationFilterPtrOutput {
	return o.ApplyT(func(v APIAccessSpec) *APIAccessSpecOperationFilter { return v.OperationFilter }).(APIAccessSpecOperationFilterPtrOutput)
}

type APIAccessSpecPtrOutput struct{ *pulumi.OutputState }

func (APIAccessSpecPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**APIAccessSpec)(nil)).Elem()
}

func (o APIAccessSpecPtrOutput) ToAPIAccessSpecPtrOutput() APIAccessSpecPtrOutput {
	return o
}

func (o APIAccessSpecPtrOutput) ToAPIAccessSpecPtrOutputWithContext(ctx context.Context) APIAccessSpecPtrOutput {
	return o
}

func (o APIAccessSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*APIAccessSpec] {
	return pulumix.Output[*APIAccessSpec]{
		OutputState: o.OutputState,
	}
}

func (o APIAccessSpecPtrOutput) Elem() APIAccessSpecOutput {
	return o.ApplyT(func(v *APIAccessSpec) APIAccessSpec {
		if v != nil {
			return *v
		}
		var ret APIAccessSpec
		return ret
	}).(APIAccessSpecOutput)
}

// APISelector selects the APIs that will be accessible to the configured audience.
// Multiple APIAccesses can select the same set of APIs.
// This field is optional and follows standard label selector semantics.
// An empty APISelector matches any API.
func (o APIAccessSpecPtrOutput) ApiSelector() APIAccessSpecApiSelectorPtrOutput {
	return o.ApplyT(func(v *APIAccessSpec) *APIAccessSpecApiSelector {
		if v == nil {
			return nil
		}
		return v.ApiSelector
	}).(APIAccessSpecApiSelectorPtrOutput)
}

// APIs defines a set of APIs that will be accessible to the configured audience.
// Multiple APIAccesses can select the same APIs.
// When combined with APISelector, this set of APIs is appended to the matching APIs.
func (o APIAccessSpecPtrOutput) Apis() APIAccessSpecApisArrayOutput {
	return o.ApplyT(func(v *APIAccessSpec) []APIAccessSpecApis {
		if v == nil {
			return nil
		}
		return v.Apis
	}).(APIAccessSpecApisArrayOutput)
}

// Everyone indicates that all users will have access to the selected APIs.
func (o APIAccessSpecPtrOutput) Everyone() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *APIAccessSpec) *bool {
		if v == nil {
			return nil
		}
		return v.Everyone
	}).(pulumi.BoolPtrOutput)
}

// Groups are the consumer groups that will gain access to the selected APIs.
func (o APIAccessSpecPtrOutput) Groups() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *APIAccessSpec) []string {
		if v == nil {
			return nil
		}
		return v.Groups
	}).(pulumi.StringArrayOutput)
}

// OperationFilter specifies the allowed operations on APIs and APIVersions.
// If not set, all operations are available.
// An empty OperationFilter prohibits all operations.
func (o APIAccessSpecPtrOutput) OperationFilter() APIAccessSpecOperationFilterPtrOutput {
	return o.ApplyT(func(v *APIAccessSpec) *APIAccessSpecOperationFilter {
		if v == nil {
			return nil
		}
		return v.OperationFilter
	}).(APIAccessSpecOperationFilterPtrOutput)
}

// APISelector selects the APIs that will be accessible to the configured audience.
// Multiple APIAccesses can select the same set of APIs.
// This field is optional and follows standard label selector semantics.
// An empty APISelector matches any API.
type APIAccessSpecApiSelector struct {
	// matchExpressions is a list of label selector requirements. The requirements are ANDed.
	MatchExpressions []APIAccessSpecApiSelectorMatchExpressions `pulumi:"matchExpressions"`
	// matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
	// map is equivalent to an element of matchExpressions, whose key field is "key", the
	// operator is "In", and the values array contains only "value". The requirements are ANDed.
	MatchLabels map[string]string `pulumi:"matchLabels"`
}

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

	ToAPIAccessSpecApiSelectorOutput() APIAccessSpecApiSelectorOutput
	ToAPIAccessSpecApiSelectorOutputWithContext(context.Context) APIAccessSpecApiSelectorOutput
}

// APISelector selects the APIs that will be accessible to the configured audience.
// Multiple APIAccesses can select the same set of APIs.
// This field is optional and follows standard label selector semantics.
// An empty APISelector matches any API.
type APIAccessSpecApiSelectorArgs struct {
	// matchExpressions is a list of label selector requirements. The requirements are ANDed.
	MatchExpressions APIAccessSpecApiSelectorMatchExpressionsArrayInput `pulumi:"matchExpressions"`
	// matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
	// map is equivalent to an element of matchExpressions, whose key field is "key", the
	// operator is "In", and the values array contains only "value". The requirements are ANDed.
	MatchLabels pulumi.StringMapInput `pulumi:"matchLabels"`
}

func (APIAccessSpecApiSelectorArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APIAccessSpecApiSelector)(nil)).Elem()
}

func (i APIAccessSpecApiSelectorArgs) ToAPIAccessSpecApiSelectorOutput() APIAccessSpecApiSelectorOutput {
	return i.ToAPIAccessSpecApiSelectorOutputWithContext(context.Background())
}

func (i APIAccessSpecApiSelectorArgs) ToAPIAccessSpecApiSelectorOutputWithContext(ctx context.Context) APIAccessSpecApiSelectorOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIAccessSpecApiSelectorOutput)
}

func (i APIAccessSpecApiSelectorArgs) ToOutput(ctx context.Context) pulumix.Output[APIAccessSpecApiSelector] {
	return pulumix.Output[APIAccessSpecApiSelector]{
		OutputState: i.ToAPIAccessSpecApiSelectorOutputWithContext(ctx).OutputState,
	}
}

func (i APIAccessSpecApiSelectorArgs) ToAPIAccessSpecApiSelectorPtrOutput() APIAccessSpecApiSelectorPtrOutput {
	return i.ToAPIAccessSpecApiSelectorPtrOutputWithContext(context.Background())
}

func (i APIAccessSpecApiSelectorArgs) ToAPIAccessSpecApiSelectorPtrOutputWithContext(ctx context.Context) APIAccessSpecApiSelectorPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIAccessSpecApiSelectorOutput).ToAPIAccessSpecApiSelectorPtrOutputWithContext(ctx)
}

// APIAccessSpecApiSelectorPtrInput is an input type that accepts APIAccessSpecApiSelectorArgs, APIAccessSpecApiSelectorPtr and APIAccessSpecApiSelectorPtrOutput values.
// You can construct a concrete instance of `APIAccessSpecApiSelectorPtrInput` via:
//
//	        APIAccessSpecApiSelectorArgs{...}
//
//	or:
//
//	        nil
type APIAccessSpecApiSelectorPtrInput interface {
	pulumi.Input

	ToAPIAccessSpecApiSelectorPtrOutput() APIAccessSpecApiSelectorPtrOutput
	ToAPIAccessSpecApiSelectorPtrOutputWithContext(context.Context) APIAccessSpecApiSelectorPtrOutput
}

type apiaccessSpecApiSelectorPtrType APIAccessSpecApiSelectorArgs

func APIAccessSpecApiSelectorPtr(v *APIAccessSpecApiSelectorArgs) APIAccessSpecApiSelectorPtrInput {
	return (*apiaccessSpecApiSelectorPtrType)(v)
}

func (*apiaccessSpecApiSelectorPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**APIAccessSpecApiSelector)(nil)).Elem()
}

func (i *apiaccessSpecApiSelectorPtrType) ToAPIAccessSpecApiSelectorPtrOutput() APIAccessSpecApiSelectorPtrOutput {
	return i.ToAPIAccessSpecApiSelectorPtrOutputWithContext(context.Background())
}

func (i *apiaccessSpecApiSelectorPtrType) ToAPIAccessSpecApiSelectorPtrOutputWithContext(ctx context.Context) APIAccessSpecApiSelectorPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIAccessSpecApiSelectorPtrOutput)
}

func (i *apiaccessSpecApiSelectorPtrType) ToOutput(ctx context.Context) pulumix.Output[*APIAccessSpecApiSelector] {
	return pulumix.Output[*APIAccessSpecApiSelector]{
		OutputState: i.ToAPIAccessSpecApiSelectorPtrOutputWithContext(ctx).OutputState,
	}
}

// APISelector selects the APIs that will be accessible to the configured audience.
// Multiple APIAccesses can select the same set of APIs.
// This field is optional and follows standard label selector semantics.
// An empty APISelector matches any API.
type APIAccessSpecApiSelectorOutput struct{ *pulumi.OutputState }

func (APIAccessSpecApiSelectorOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APIAccessSpecApiSelector)(nil)).Elem()
}

func (o APIAccessSpecApiSelectorOutput) ToAPIAccessSpecApiSelectorOutput() APIAccessSpecApiSelectorOutput {
	return o
}

func (o APIAccessSpecApiSelectorOutput) ToAPIAccessSpecApiSelectorOutputWithContext(ctx context.Context) APIAccessSpecApiSelectorOutput {
	return o
}

func (o APIAccessSpecApiSelectorOutput) ToAPIAccessSpecApiSelectorPtrOutput() APIAccessSpecApiSelectorPtrOutput {
	return o.ToAPIAccessSpecApiSelectorPtrOutputWithContext(context.Background())
}

func (o APIAccessSpecApiSelectorOutput) ToAPIAccessSpecApiSelectorPtrOutputWithContext(ctx context.Context) APIAccessSpecApiSelectorPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v APIAccessSpecApiSelector) *APIAccessSpecApiSelector {
		return &v
	}).(APIAccessSpecApiSelectorPtrOutput)
}

func (o APIAccessSpecApiSelectorOutput) ToOutput(ctx context.Context) pulumix.Output[APIAccessSpecApiSelector] {
	return pulumix.Output[APIAccessSpecApiSelector]{
		OutputState: o.OutputState,
	}
}

// matchExpressions is a list of label selector requirements. The requirements are ANDed.
func (o APIAccessSpecApiSelectorOutput) MatchExpressions() APIAccessSpecApiSelectorMatchExpressionsArrayOutput {
	return o.ApplyT(func(v APIAccessSpecApiSelector) []APIAccessSpecApiSelectorMatchExpressions { return v.MatchExpressions }).(APIAccessSpecApiSelectorMatchExpressionsArrayOutput)
}

// matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
// map is equivalent to an element of matchExpressions, whose key field is "key", the
// operator is "In", and the values array contains only "value". The requirements are ANDed.
func (o APIAccessSpecApiSelectorOutput) MatchLabels() pulumi.StringMapOutput {
	return o.ApplyT(func(v APIAccessSpecApiSelector) map[string]string { return v.MatchLabels }).(pulumi.StringMapOutput)
}

type APIAccessSpecApiSelectorPtrOutput struct{ *pulumi.OutputState }

func (APIAccessSpecApiSelectorPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**APIAccessSpecApiSelector)(nil)).Elem()
}

func (o APIAccessSpecApiSelectorPtrOutput) ToAPIAccessSpecApiSelectorPtrOutput() APIAccessSpecApiSelectorPtrOutput {
	return o
}

func (o APIAccessSpecApiSelectorPtrOutput) ToAPIAccessSpecApiSelectorPtrOutputWithContext(ctx context.Context) APIAccessSpecApiSelectorPtrOutput {
	return o
}

func (o APIAccessSpecApiSelectorPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*APIAccessSpecApiSelector] {
	return pulumix.Output[*APIAccessSpecApiSelector]{
		OutputState: o.OutputState,
	}
}

func (o APIAccessSpecApiSelectorPtrOutput) Elem() APIAccessSpecApiSelectorOutput {
	return o.ApplyT(func(v *APIAccessSpecApiSelector) APIAccessSpecApiSelector {
		if v != nil {
			return *v
		}
		var ret APIAccessSpecApiSelector
		return ret
	}).(APIAccessSpecApiSelectorOutput)
}

// matchExpressions is a list of label selector requirements. The requirements are ANDed.
func (o APIAccessSpecApiSelectorPtrOutput) MatchExpressions() APIAccessSpecApiSelectorMatchExpressionsArrayOutput {
	return o.ApplyT(func(v *APIAccessSpecApiSelector) []APIAccessSpecApiSelectorMatchExpressions {
		if v == nil {
			return nil
		}
		return v.MatchExpressions
	}).(APIAccessSpecApiSelectorMatchExpressionsArrayOutput)
}

// matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
// map is equivalent to an element of matchExpressions, whose key field is "key", the
// operator is "In", and the values array contains only "value". The requirements are ANDed.
func (o APIAccessSpecApiSelectorPtrOutput) MatchLabels() pulumi.StringMapOutput {
	return o.ApplyT(func(v *APIAccessSpecApiSelector) map[string]string {
		if v == nil {
			return nil
		}
		return v.MatchLabels
	}).(pulumi.StringMapOutput)
}

// A label selector requirement is a selector that contains values, a key, and an operator that
// relates the key and values.
type APIAccessSpecApiSelectorMatchExpressions struct {
	// key is the label key that the selector applies to.
	Key string `pulumi:"key"`
	// operator represents a key's relationship to a set of values.
	// Valid operators are In, NotIn, Exists and DoesNotExist.
	Operator string `pulumi:"operator"`
	// values is an array of string values. If the operator is In or NotIn,
	// the values array must be non-empty. If the operator is Exists or DoesNotExist,
	// the values array must be empty. This array is replaced during a strategic
	// merge patch.
	Values []string `pulumi:"values"`
}

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

	ToAPIAccessSpecApiSelectorMatchExpressionsOutput() APIAccessSpecApiSelectorMatchExpressionsOutput
	ToAPIAccessSpecApiSelectorMatchExpressionsOutputWithContext(context.Context) APIAccessSpecApiSelectorMatchExpressionsOutput
}

// A label selector requirement is a selector that contains values, a key, and an operator that
// relates the key and values.
type APIAccessSpecApiSelectorMatchExpressionsArgs struct {
	// key is the label key that the selector applies to.
	Key pulumi.StringInput `pulumi:"key"`
	// operator represents a key's relationship to a set of values.
	// Valid operators are In, NotIn, Exists and DoesNotExist.
	Operator pulumi.StringInput `pulumi:"operator"`
	// values is an array of string values. If the operator is In or NotIn,
	// the values array must be non-empty. If the operator is Exists or DoesNotExist,
	// the values array must be empty. This array is replaced during a strategic
	// merge patch.
	Values pulumi.StringArrayInput `pulumi:"values"`
}

func (APIAccessSpecApiSelectorMatchExpressionsArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APIAccessSpecApiSelectorMatchExpressions)(nil)).Elem()
}

func (i APIAccessSpecApiSelectorMatchExpressionsArgs) ToAPIAccessSpecApiSelectorMatchExpressionsOutput() APIAccessSpecApiSelectorMatchExpressionsOutput {
	return i.ToAPIAccessSpecApiSelectorMatchExpressionsOutputWithContext(context.Background())
}

func (i APIAccessSpecApiSelectorMatchExpressionsArgs) ToAPIAccessSpecApiSelectorMatchExpressionsOutputWithContext(ctx context.Context) APIAccessSpecApiSelectorMatchExpressionsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIAccessSpecApiSelectorMatchExpressionsOutput)
}

func (i APIAccessSpecApiSelectorMatchExpressionsArgs) ToOutput(ctx context.Context) pulumix.Output[APIAccessSpecApiSelectorMatchExpressions] {
	return pulumix.Output[APIAccessSpecApiSelectorMatchExpressions]{
		OutputState: i.ToAPIAccessSpecApiSelectorMatchExpressionsOutputWithContext(ctx).OutputState,
	}
}

// APIAccessSpecApiSelectorMatchExpressionsArrayInput is an input type that accepts APIAccessSpecApiSelectorMatchExpressionsArray and APIAccessSpecApiSelectorMatchExpressionsArrayOutput values.
// You can construct a concrete instance of `APIAccessSpecApiSelectorMatchExpressionsArrayInput` via:
//
//	APIAccessSpecApiSelectorMatchExpressionsArray{ APIAccessSpecApiSelectorMatchExpressionsArgs{...} }
type APIAccessSpecApiSelectorMatchExpressionsArrayInput interface {
	pulumi.Input

	ToAPIAccessSpecApiSelectorMatchExpressionsArrayOutput() APIAccessSpecApiSelectorMatchExpressionsArrayOutput
	ToAPIAccessSpecApiSelectorMatchExpressionsArrayOutputWithContext(context.Context) APIAccessSpecApiSelectorMatchExpressionsArrayOutput
}

type APIAccessSpecApiSelectorMatchExpressionsArray []APIAccessSpecApiSelectorMatchExpressionsInput

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

func (i APIAccessSpecApiSelectorMatchExpressionsArray) ToAPIAccessSpecApiSelectorMatchExpressionsArrayOutput() APIAccessSpecApiSelectorMatchExpressionsArrayOutput {
	return i.ToAPIAccessSpecApiSelectorMatchExpressionsArrayOutputWithContext(context.Background())
}

func (i APIAccessSpecApiSelectorMatchExpressionsArray) ToAPIAccessSpecApiSelectorMatchExpressionsArrayOutputWithContext(ctx context.Context) APIAccessSpecApiSelectorMatchExpressionsArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIAccessSpecApiSelectorMatchExpressionsArrayOutput)
}

func (i APIAccessSpecApiSelectorMatchExpressionsArray) ToOutput(ctx context.Context) pulumix.Output[[]APIAccessSpecApiSelectorMatchExpressions] {
	return pulumix.Output[[]APIAccessSpecApiSelectorMatchExpressions]{
		OutputState: i.ToAPIAccessSpecApiSelectorMatchExpressionsArrayOutputWithContext(ctx).OutputState,
	}
}

// A label selector requirement is a selector that contains values, a key, and an operator that
// relates the key and values.
type APIAccessSpecApiSelectorMatchExpressionsOutput struct{ *pulumi.OutputState }

func (APIAccessSpecApiSelectorMatchExpressionsOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APIAccessSpecApiSelectorMatchExpressions)(nil)).Elem()
}

func (o APIAccessSpecApiSelectorMatchExpressionsOutput) ToAPIAccessSpecApiSelectorMatchExpressionsOutput() APIAccessSpecApiSelectorMatchExpressionsOutput {
	return o
}

func (o APIAccessSpecApiSelectorMatchExpressionsOutput) ToAPIAccessSpecApiSelectorMatchExpressionsOutputWithContext(ctx context.Context) APIAccessSpecApiSelectorMatchExpressionsOutput {
	return o
}

func (o APIAccessSpecApiSelectorMatchExpressionsOutput) ToOutput(ctx context.Context) pulumix.Output[APIAccessSpecApiSelectorMatchExpressions] {
	return pulumix.Output[APIAccessSpecApiSelectorMatchExpressions]{
		OutputState: o.OutputState,
	}
}

// key is the label key that the selector applies to.
func (o APIAccessSpecApiSelectorMatchExpressionsOutput) Key() pulumi.StringOutput {
	return o.ApplyT(func(v APIAccessSpecApiSelectorMatchExpressions) string { return v.Key }).(pulumi.StringOutput)
}

// operator represents a key's relationship to a set of values.
// Valid operators are In, NotIn, Exists and DoesNotExist.
func (o APIAccessSpecApiSelectorMatchExpressionsOutput) Operator() pulumi.StringOutput {
	return o.ApplyT(func(v APIAccessSpecApiSelectorMatchExpressions) string { return v.Operator }).(pulumi.StringOutput)
}

// values is an array of string values. If the operator is In or NotIn,
// the values array must be non-empty. If the operator is Exists or DoesNotExist,
// the values array must be empty. This array is replaced during a strategic
// merge patch.
func (o APIAccessSpecApiSelectorMatchExpressionsOutput) Values() pulumi.StringArrayOutput {
	return o.ApplyT(func(v APIAccessSpecApiSelectorMatchExpressions) []string { return v.Values }).(pulumi.StringArrayOutput)
}

type APIAccessSpecApiSelectorMatchExpressionsArrayOutput struct{ *pulumi.OutputState }

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

func (o APIAccessSpecApiSelectorMatchExpressionsArrayOutput) ToAPIAccessSpecApiSelectorMatchExpressionsArrayOutput() APIAccessSpecApiSelectorMatchExpressionsArrayOutput {
	return o
}

func (o APIAccessSpecApiSelectorMatchExpressionsArrayOutput) ToAPIAccessSpecApiSelectorMatchExpressionsArrayOutputWithContext(ctx context.Context) APIAccessSpecApiSelectorMatchExpressionsArrayOutput {
	return o
}

func (o APIAccessSpecApiSelectorMatchExpressionsArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]APIAccessSpecApiSelectorMatchExpressions] {
	return pulumix.Output[[]APIAccessSpecApiSelectorMatchExpressions]{
		OutputState: o.OutputState,
	}
}

func (o APIAccessSpecApiSelectorMatchExpressionsArrayOutput) Index(i pulumi.IntInput) APIAccessSpecApiSelectorMatchExpressionsOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) APIAccessSpecApiSelectorMatchExpressions {
		return vs[0].([]APIAccessSpecApiSelectorMatchExpressions)[vs[1].(int)]
	}).(APIAccessSpecApiSelectorMatchExpressionsOutput)
}

// matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
// map is equivalent to an element of matchExpressions, whose key field is "key", the
// operator is "In", and the values array contains only "value". The requirements are ANDed.
type APIAccessSpecApiSelectorMatchLabels struct {
}

// APIReference references an API.
type APIAccessSpecApis struct {
	// Name of the API.
	Name string `pulumi:"name"`
}

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

	ToAPIAccessSpecApisOutput() APIAccessSpecApisOutput
	ToAPIAccessSpecApisOutputWithContext(context.Context) APIAccessSpecApisOutput
}

// APIReference references an API.
type APIAccessSpecApisArgs struct {
	// Name of the API.
	Name pulumi.StringInput `pulumi:"name"`
}

func (APIAccessSpecApisArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APIAccessSpecApis)(nil)).Elem()
}

func (i APIAccessSpecApisArgs) ToAPIAccessSpecApisOutput() APIAccessSpecApisOutput {
	return i.ToAPIAccessSpecApisOutputWithContext(context.Background())
}

func (i APIAccessSpecApisArgs) ToAPIAccessSpecApisOutputWithContext(ctx context.Context) APIAccessSpecApisOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIAccessSpecApisOutput)
}

func (i APIAccessSpecApisArgs) ToOutput(ctx context.Context) pulumix.Output[APIAccessSpecApis] {
	return pulumix.Output[APIAccessSpecApis]{
		OutputState: i.ToAPIAccessSpecApisOutputWithContext(ctx).OutputState,
	}
}

// APIAccessSpecApisArrayInput is an input type that accepts APIAccessSpecApisArray and APIAccessSpecApisArrayOutput values.
// You can construct a concrete instance of `APIAccessSpecApisArrayInput` via:
//
//	APIAccessSpecApisArray{ APIAccessSpecApisArgs{...} }
type APIAccessSpecApisArrayInput interface {
	pulumi.Input

	ToAPIAccessSpecApisArrayOutput() APIAccessSpecApisArrayOutput
	ToAPIAccessSpecApisArrayOutputWithContext(context.Context) APIAccessSpecApisArrayOutput
}

type APIAccessSpecApisArray []APIAccessSpecApisInput

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

func (i APIAccessSpecApisArray) ToAPIAccessSpecApisArrayOutput() APIAccessSpecApisArrayOutput {
	return i.ToAPIAccessSpecApisArrayOutputWithContext(context.Background())
}

func (i APIAccessSpecApisArray) ToAPIAccessSpecApisArrayOutputWithContext(ctx context.Context) APIAccessSpecApisArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIAccessSpecApisArrayOutput)
}

func (i APIAccessSpecApisArray) ToOutput(ctx context.Context) pulumix.Output[[]APIAccessSpecApis] {
	return pulumix.Output[[]APIAccessSpecApis]{
		OutputState: i.ToAPIAccessSpecApisArrayOutputWithContext(ctx).OutputState,
	}
}

// APIReference references an API.
type APIAccessSpecApisOutput struct{ *pulumi.OutputState }

func (APIAccessSpecApisOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APIAccessSpecApis)(nil)).Elem()
}

func (o APIAccessSpecApisOutput) ToAPIAccessSpecApisOutput() APIAccessSpecApisOutput {
	return o
}

func (o APIAccessSpecApisOutput) ToAPIAccessSpecApisOutputWithContext(ctx context.Context) APIAccessSpecApisOutput {
	return o
}

func (o APIAccessSpecApisOutput) ToOutput(ctx context.Context) pulumix.Output[APIAccessSpecApis] {
	return pulumix.Output[APIAccessSpecApis]{
		OutputState: o.OutputState,
	}
}

// Name of the API.
func (o APIAccessSpecApisOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v APIAccessSpecApis) string { return v.Name }).(pulumi.StringOutput)
}

type APIAccessSpecApisArrayOutput struct{ *pulumi.OutputState }

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

func (o APIAccessSpecApisArrayOutput) ToAPIAccessSpecApisArrayOutput() APIAccessSpecApisArrayOutput {
	return o
}

func (o APIAccessSpecApisArrayOutput) ToAPIAccessSpecApisArrayOutputWithContext(ctx context.Context) APIAccessSpecApisArrayOutput {
	return o
}

func (o APIAccessSpecApisArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]APIAccessSpecApis] {
	return pulumix.Output[[]APIAccessSpecApis]{
		OutputState: o.OutputState,
	}
}

func (o APIAccessSpecApisArrayOutput) Index(i pulumi.IntInput) APIAccessSpecApisOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) APIAccessSpecApis {
		return vs[0].([]APIAccessSpecApis)[vs[1].(int)]
	}).(APIAccessSpecApisOutput)
}

// OperationFilter specifies the allowed operations on APIs and APIVersions.
// If not set, all operations are available.
// An empty OperationFilter prohibits all operations.
type APIAccessSpecOperationFilter struct {
	// Include defines the names of OperationSets that will be accessible.
	Include []string `pulumi:"include"`
}

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

	ToAPIAccessSpecOperationFilterOutput() APIAccessSpecOperationFilterOutput
	ToAPIAccessSpecOperationFilterOutputWithContext(context.Context) APIAccessSpecOperationFilterOutput
}

// OperationFilter specifies the allowed operations on APIs and APIVersions.
// If not set, all operations are available.
// An empty OperationFilter prohibits all operations.
type APIAccessSpecOperationFilterArgs struct {
	// Include defines the names of OperationSets that will be accessible.
	Include pulumi.StringArrayInput `pulumi:"include"`
}

func (APIAccessSpecOperationFilterArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APIAccessSpecOperationFilter)(nil)).Elem()
}

func (i APIAccessSpecOperationFilterArgs) ToAPIAccessSpecOperationFilterOutput() APIAccessSpecOperationFilterOutput {
	return i.ToAPIAccessSpecOperationFilterOutputWithContext(context.Background())
}

func (i APIAccessSpecOperationFilterArgs) ToAPIAccessSpecOperationFilterOutputWithContext(ctx context.Context) APIAccessSpecOperationFilterOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIAccessSpecOperationFilterOutput)
}

func (i APIAccessSpecOperationFilterArgs) ToOutput(ctx context.Context) pulumix.Output[APIAccessSpecOperationFilter] {
	return pulumix.Output[APIAccessSpecOperationFilter]{
		OutputState: i.ToAPIAccessSpecOperationFilterOutputWithContext(ctx).OutputState,
	}
}

func (i APIAccessSpecOperationFilterArgs) ToAPIAccessSpecOperationFilterPtrOutput() APIAccessSpecOperationFilterPtrOutput {
	return i.ToAPIAccessSpecOperationFilterPtrOutputWithContext(context.Background())
}

func (i APIAccessSpecOperationFilterArgs) ToAPIAccessSpecOperationFilterPtrOutputWithContext(ctx context.Context) APIAccessSpecOperationFilterPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIAccessSpecOperationFilterOutput).ToAPIAccessSpecOperationFilterPtrOutputWithContext(ctx)
}

// APIAccessSpecOperationFilterPtrInput is an input type that accepts APIAccessSpecOperationFilterArgs, APIAccessSpecOperationFilterPtr and APIAccessSpecOperationFilterPtrOutput values.
// You can construct a concrete instance of `APIAccessSpecOperationFilterPtrInput` via:
//
//	        APIAccessSpecOperationFilterArgs{...}
//
//	or:
//
//	        nil
type APIAccessSpecOperationFilterPtrInput interface {
	pulumi.Input

	ToAPIAccessSpecOperationFilterPtrOutput() APIAccessSpecOperationFilterPtrOutput
	ToAPIAccessSpecOperationFilterPtrOutputWithContext(context.Context) APIAccessSpecOperationFilterPtrOutput
}

type apiaccessSpecOperationFilterPtrType APIAccessSpecOperationFilterArgs

func APIAccessSpecOperationFilterPtr(v *APIAccessSpecOperationFilterArgs) APIAccessSpecOperationFilterPtrInput {
	return (*apiaccessSpecOperationFilterPtrType)(v)
}

func (*apiaccessSpecOperationFilterPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**APIAccessSpecOperationFilter)(nil)).Elem()
}

func (i *apiaccessSpecOperationFilterPtrType) ToAPIAccessSpecOperationFilterPtrOutput() APIAccessSpecOperationFilterPtrOutput {
	return i.ToAPIAccessSpecOperationFilterPtrOutputWithContext(context.Background())
}

func (i *apiaccessSpecOperationFilterPtrType) ToAPIAccessSpecOperationFilterPtrOutputWithContext(ctx context.Context) APIAccessSpecOperationFilterPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIAccessSpecOperationFilterPtrOutput)
}

func (i *apiaccessSpecOperationFilterPtrType) ToOutput(ctx context.Context) pulumix.Output[*APIAccessSpecOperationFilter] {
	return pulumix.Output[*APIAccessSpecOperationFilter]{
		OutputState: i.ToAPIAccessSpecOperationFilterPtrOutputWithContext(ctx).OutputState,
	}
}

// OperationFilter specifies the allowed operations on APIs and APIVersions.
// If not set, all operations are available.
// An empty OperationFilter prohibits all operations.
type APIAccessSpecOperationFilterOutput struct{ *pulumi.OutputState }

func (APIAccessSpecOperationFilterOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APIAccessSpecOperationFilter)(nil)).Elem()
}

func (o APIAccessSpecOperationFilterOutput) ToAPIAccessSpecOperationFilterOutput() APIAccessSpecOperationFilterOutput {
	return o
}

func (o APIAccessSpecOperationFilterOutput) ToAPIAccessSpecOperationFilterOutputWithContext(ctx context.Context) APIAccessSpecOperationFilterOutput {
	return o
}

func (o APIAccessSpecOperationFilterOutput) ToAPIAccessSpecOperationFilterPtrOutput() APIAccessSpecOperationFilterPtrOutput {
	return o.ToAPIAccessSpecOperationFilterPtrOutputWithContext(context.Background())
}

func (o APIAccessSpecOperationFilterOutput) ToAPIAccessSpecOperationFilterPtrOutputWithContext(ctx context.Context) APIAccessSpecOperationFilterPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v APIAccessSpecOperationFilter) *APIAccessSpecOperationFilter {
		return &v
	}).(APIAccessSpecOperationFilterPtrOutput)
}

func (o APIAccessSpecOperationFilterOutput) ToOutput(ctx context.Context) pulumix.Output[APIAccessSpecOperationFilter] {
	return pulumix.Output[APIAccessSpecOperationFilter]{
		OutputState: o.OutputState,
	}
}

// Include defines the names of OperationSets that will be accessible.
func (o APIAccessSpecOperationFilterOutput) Include() pulumi.StringArrayOutput {
	return o.ApplyT(func(v APIAccessSpecOperationFilter) []string { return v.Include }).(pulumi.StringArrayOutput)
}

type APIAccessSpecOperationFilterPtrOutput struct{ *pulumi.OutputState }

func (APIAccessSpecOperationFilterPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**APIAccessSpecOperationFilter)(nil)).Elem()
}

func (o APIAccessSpecOperationFilterPtrOutput) ToAPIAccessSpecOperationFilterPtrOutput() APIAccessSpecOperationFilterPtrOutput {
	return o
}

func (o APIAccessSpecOperationFilterPtrOutput) ToAPIAccessSpecOperationFilterPtrOutputWithContext(ctx context.Context) APIAccessSpecOperationFilterPtrOutput {
	return o
}

func (o APIAccessSpecOperationFilterPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*APIAccessSpecOperationFilter] {
	return pulumix.Output[*APIAccessSpecOperationFilter]{
		OutputState: o.OutputState,
	}
}

func (o APIAccessSpecOperationFilterPtrOutput) Elem() APIAccessSpecOperationFilterOutput {
	return o.ApplyT(func(v *APIAccessSpecOperationFilter) APIAccessSpecOperationFilter {
		if v != nil {
			return *v
		}
		var ret APIAccessSpecOperationFilter
		return ret
	}).(APIAccessSpecOperationFilterOutput)
}

// Include defines the names of OperationSets that will be accessible.
func (o APIAccessSpecOperationFilterPtrOutput) Include() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *APIAccessSpecOperationFilter) []string {
		if v == nil {
			return nil
		}
		return v.Include
	}).(pulumi.StringArrayOutput)
}

// The current status of this APIAccess.
type APIAccessStatus struct {
	// Hash is a hash representing the APIAccess.
	Hash     *string `pulumi:"hash"`
	SyncedAt *string `pulumi:"syncedAt"`
	Version  *string `pulumi:"version"`
}

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

	ToAPIAccessStatusOutput() APIAccessStatusOutput
	ToAPIAccessStatusOutputWithContext(context.Context) APIAccessStatusOutput
}

// The current status of this APIAccess.
type APIAccessStatusArgs struct {
	// Hash is a hash representing the APIAccess.
	Hash     pulumi.StringPtrInput `pulumi:"hash"`
	SyncedAt pulumi.StringPtrInput `pulumi:"syncedAt"`
	Version  pulumi.StringPtrInput `pulumi:"version"`
}

func (APIAccessStatusArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APIAccessStatus)(nil)).Elem()
}

func (i APIAccessStatusArgs) ToAPIAccessStatusOutput() APIAccessStatusOutput {
	return i.ToAPIAccessStatusOutputWithContext(context.Background())
}

func (i APIAccessStatusArgs) ToAPIAccessStatusOutputWithContext(ctx context.Context) APIAccessStatusOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIAccessStatusOutput)
}

func (i APIAccessStatusArgs) ToOutput(ctx context.Context) pulumix.Output[APIAccessStatus] {
	return pulumix.Output[APIAccessStatus]{
		OutputState: i.ToAPIAccessStatusOutputWithContext(ctx).OutputState,
	}
}

func (i APIAccessStatusArgs) ToAPIAccessStatusPtrOutput() APIAccessStatusPtrOutput {
	return i.ToAPIAccessStatusPtrOutputWithContext(context.Background())
}

func (i APIAccessStatusArgs) ToAPIAccessStatusPtrOutputWithContext(ctx context.Context) APIAccessStatusPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIAccessStatusOutput).ToAPIAccessStatusPtrOutputWithContext(ctx)
}

// APIAccessStatusPtrInput is an input type that accepts APIAccessStatusArgs, APIAccessStatusPtr and APIAccessStatusPtrOutput values.
// You can construct a concrete instance of `APIAccessStatusPtrInput` via:
//
//	        APIAccessStatusArgs{...}
//
//	or:
//
//	        nil
type APIAccessStatusPtrInput interface {
	pulumi.Input

	ToAPIAccessStatusPtrOutput() APIAccessStatusPtrOutput
	ToAPIAccessStatusPtrOutputWithContext(context.Context) APIAccessStatusPtrOutput
}

type apiaccessStatusPtrType APIAccessStatusArgs

func APIAccessStatusPtr(v *APIAccessStatusArgs) APIAccessStatusPtrInput {
	return (*apiaccessStatusPtrType)(v)
}

func (*apiaccessStatusPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**APIAccessStatus)(nil)).Elem()
}

func (i *apiaccessStatusPtrType) ToAPIAccessStatusPtrOutput() APIAccessStatusPtrOutput {
	return i.ToAPIAccessStatusPtrOutputWithContext(context.Background())
}

func (i *apiaccessStatusPtrType) ToAPIAccessStatusPtrOutputWithContext(ctx context.Context) APIAccessStatusPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIAccessStatusPtrOutput)
}

func (i *apiaccessStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*APIAccessStatus] {
	return pulumix.Output[*APIAccessStatus]{
		OutputState: i.ToAPIAccessStatusPtrOutputWithContext(ctx).OutputState,
	}
}

// The current status of this APIAccess.
type APIAccessStatusOutput struct{ *pulumi.OutputState }

func (APIAccessStatusOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APIAccessStatus)(nil)).Elem()
}

func (o APIAccessStatusOutput) ToAPIAccessStatusOutput() APIAccessStatusOutput {
	return o
}

func (o APIAccessStatusOutput) ToAPIAccessStatusOutputWithContext(ctx context.Context) APIAccessStatusOutput {
	return o
}

func (o APIAccessStatusOutput) ToAPIAccessStatusPtrOutput() APIAccessStatusPtrOutput {
	return o.ToAPIAccessStatusPtrOutputWithContext(context.Background())
}

func (o APIAccessStatusOutput) ToAPIAccessStatusPtrOutputWithContext(ctx context.Context) APIAccessStatusPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v APIAccessStatus) *APIAccessStatus {
		return &v
	}).(APIAccessStatusPtrOutput)
}

func (o APIAccessStatusOutput) ToOutput(ctx context.Context) pulumix.Output[APIAccessStatus] {
	return pulumix.Output[APIAccessStatus]{
		OutputState: o.OutputState,
	}
}

// Hash is a hash representing the APIAccess.
func (o APIAccessStatusOutput) Hash() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIAccessStatus) *string { return v.Hash }).(pulumi.StringPtrOutput)
}

func (o APIAccessStatusOutput) SyncedAt() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIAccessStatus) *string { return v.SyncedAt }).(pulumi.StringPtrOutput)
}

func (o APIAccessStatusOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIAccessStatus) *string { return v.Version }).(pulumi.StringPtrOutput)
}

type APIAccessStatusPtrOutput struct{ *pulumi.OutputState }

func (APIAccessStatusPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**APIAccessStatus)(nil)).Elem()
}

func (o APIAccessStatusPtrOutput) ToAPIAccessStatusPtrOutput() APIAccessStatusPtrOutput {
	return o
}

func (o APIAccessStatusPtrOutput) ToAPIAccessStatusPtrOutputWithContext(ctx context.Context) APIAccessStatusPtrOutput {
	return o
}

func (o APIAccessStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*APIAccessStatus] {
	return pulumix.Output[*APIAccessStatus]{
		OutputState: o.OutputState,
	}
}

func (o APIAccessStatusPtrOutput) Elem() APIAccessStatusOutput {
	return o.ApplyT(func(v *APIAccessStatus) APIAccessStatus {
		if v != nil {
			return *v
		}
		var ret APIAccessStatus
		return ret
	}).(APIAccessStatusOutput)
}

// Hash is a hash representing the APIAccess.
func (o APIAccessStatusPtrOutput) Hash() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIAccessStatus) *string {
		if v == nil {
			return nil
		}
		return v.Hash
	}).(pulumi.StringPtrOutput)
}

func (o APIAccessStatusPtrOutput) SyncedAt() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIAccessStatus) *string {
		if v == nil {
			return nil
		}
		return v.SyncedAt
	}).(pulumi.StringPtrOutput)
}

func (o APIAccessStatusPtrOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIAccessStatus) *string {
		if v == nil {
			return nil
		}
		return v.Version
	}).(pulumi.StringPtrOutput)
}

type APIMetadata struct {
}

// APIPortal defines a developer portal for accessing the documentation of APIs.
type APIPortalType struct {
	ApiVersion *string        `pulumi:"apiVersion"`
	Kind       *string        `pulumi:"kind"`
	Metadata   *v1.ObjectMeta `pulumi:"metadata"`
	// The desired behavior of this APIPortal.
	Spec *APIPortalSpec `pulumi:"spec"`
	// The current status of this APIPortal.
	Status *APIPortalStatus `pulumi:"status"`
}

type APIPortalMetadata struct {
}

// The desired behavior of this APIPortal.
type APIPortalSpec struct {
	// Description of the APIPortal.
	Description *string `pulumi:"description"`
	// Title is the public facing name of the APIPortal.
	Title *string `pulumi:"title"`
	// TrustedURLs are the urls that are trusted by the OAuth 2.0 authorization server.
	TrustedUrls []string `pulumi:"trustedUrls"`
	// UI holds the UI customization options.
	Ui *APIPortalSpecUi `pulumi:"ui"`
}

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

	ToAPIPortalSpecOutput() APIPortalSpecOutput
	ToAPIPortalSpecOutputWithContext(context.Context) APIPortalSpecOutput
}

// The desired behavior of this APIPortal.
type APIPortalSpecArgs struct {
	// Description of the APIPortal.
	Description pulumi.StringPtrInput `pulumi:"description"`
	// Title is the public facing name of the APIPortal.
	Title pulumi.StringPtrInput `pulumi:"title"`
	// TrustedURLs are the urls that are trusted by the OAuth 2.0 authorization server.
	TrustedUrls pulumi.StringArrayInput `pulumi:"trustedUrls"`
	// UI holds the UI customization options.
	Ui APIPortalSpecUiPtrInput `pulumi:"ui"`
}

func (APIPortalSpecArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APIPortalSpec)(nil)).Elem()
}

func (i APIPortalSpecArgs) ToAPIPortalSpecOutput() APIPortalSpecOutput {
	return i.ToAPIPortalSpecOutputWithContext(context.Background())
}

func (i APIPortalSpecArgs) ToAPIPortalSpecOutputWithContext(ctx context.Context) APIPortalSpecOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIPortalSpecOutput)
}

func (i APIPortalSpecArgs) ToOutput(ctx context.Context) pulumix.Output[APIPortalSpec] {
	return pulumix.Output[APIPortalSpec]{
		OutputState: i.ToAPIPortalSpecOutputWithContext(ctx).OutputState,
	}
}

func (i APIPortalSpecArgs) ToAPIPortalSpecPtrOutput() APIPortalSpecPtrOutput {
	return i.ToAPIPortalSpecPtrOutputWithContext(context.Background())
}

func (i APIPortalSpecArgs) ToAPIPortalSpecPtrOutputWithContext(ctx context.Context) APIPortalSpecPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIPortalSpecOutput).ToAPIPortalSpecPtrOutputWithContext(ctx)
}

// APIPortalSpecPtrInput is an input type that accepts APIPortalSpecArgs, APIPortalSpecPtr and APIPortalSpecPtrOutput values.
// You can construct a concrete instance of `APIPortalSpecPtrInput` via:
//
//	        APIPortalSpecArgs{...}
//
//	or:
//
//	        nil
type APIPortalSpecPtrInput interface {
	pulumi.Input

	ToAPIPortalSpecPtrOutput() APIPortalSpecPtrOutput
	ToAPIPortalSpecPtrOutputWithContext(context.Context) APIPortalSpecPtrOutput
}

type apiportalSpecPtrType APIPortalSpecArgs

func APIPortalSpecPtr(v *APIPortalSpecArgs) APIPortalSpecPtrInput {
	return (*apiportalSpecPtrType)(v)
}

func (*apiportalSpecPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**APIPortalSpec)(nil)).Elem()
}

func (i *apiportalSpecPtrType) ToAPIPortalSpecPtrOutput() APIPortalSpecPtrOutput {
	return i.ToAPIPortalSpecPtrOutputWithContext(context.Background())
}

func (i *apiportalSpecPtrType) ToAPIPortalSpecPtrOutputWithContext(ctx context.Context) APIPortalSpecPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIPortalSpecPtrOutput)
}

func (i *apiportalSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*APIPortalSpec] {
	return pulumix.Output[*APIPortalSpec]{
		OutputState: i.ToAPIPortalSpecPtrOutputWithContext(ctx).OutputState,
	}
}

// The desired behavior of this APIPortal.
type APIPortalSpecOutput struct{ *pulumi.OutputState }

func (APIPortalSpecOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APIPortalSpec)(nil)).Elem()
}

func (o APIPortalSpecOutput) ToAPIPortalSpecOutput() APIPortalSpecOutput {
	return o
}

func (o APIPortalSpecOutput) ToAPIPortalSpecOutputWithContext(ctx context.Context) APIPortalSpecOutput {
	return o
}

func (o APIPortalSpecOutput) ToAPIPortalSpecPtrOutput() APIPortalSpecPtrOutput {
	return o.ToAPIPortalSpecPtrOutputWithContext(context.Background())
}

func (o APIPortalSpecOutput) ToAPIPortalSpecPtrOutputWithContext(ctx context.Context) APIPortalSpecPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v APIPortalSpec) *APIPortalSpec {
		return &v
	}).(APIPortalSpecPtrOutput)
}

func (o APIPortalSpecOutput) ToOutput(ctx context.Context) pulumix.Output[APIPortalSpec] {
	return pulumix.Output[APIPortalSpec]{
		OutputState: o.OutputState,
	}
}

// Description of the APIPortal.
func (o APIPortalSpecOutput) Description() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIPortalSpec) *string { return v.Description }).(pulumi.StringPtrOutput)
}

// Title is the public facing name of the APIPortal.
func (o APIPortalSpecOutput) Title() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIPortalSpec) *string { return v.Title }).(pulumi.StringPtrOutput)
}

// TrustedURLs are the urls that are trusted by the OAuth 2.0 authorization server.
func (o APIPortalSpecOutput) TrustedUrls() pulumi.StringArrayOutput {
	return o.ApplyT(func(v APIPortalSpec) []string { return v.TrustedUrls }).(pulumi.StringArrayOutput)
}

// UI holds the UI customization options.
func (o APIPortalSpecOutput) Ui() APIPortalSpecUiPtrOutput {
	return o.ApplyT(func(v APIPortalSpec) *APIPortalSpecUi { return v.Ui }).(APIPortalSpecUiPtrOutput)
}

type APIPortalSpecPtrOutput struct{ *pulumi.OutputState }

func (APIPortalSpecPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**APIPortalSpec)(nil)).Elem()
}

func (o APIPortalSpecPtrOutput) ToAPIPortalSpecPtrOutput() APIPortalSpecPtrOutput {
	return o
}

func (o APIPortalSpecPtrOutput) ToAPIPortalSpecPtrOutputWithContext(ctx context.Context) APIPortalSpecPtrOutput {
	return o
}

func (o APIPortalSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*APIPortalSpec] {
	return pulumix.Output[*APIPortalSpec]{
		OutputState: o.OutputState,
	}
}

func (o APIPortalSpecPtrOutput) Elem() APIPortalSpecOutput {
	return o.ApplyT(func(v *APIPortalSpec) APIPortalSpec {
		if v != nil {
			return *v
		}
		var ret APIPortalSpec
		return ret
	}).(APIPortalSpecOutput)
}

// Description of the APIPortal.
func (o APIPortalSpecPtrOutput) Description() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIPortalSpec) *string {
		if v == nil {
			return nil
		}
		return v.Description
	}).(pulumi.StringPtrOutput)
}

// Title is the public facing name of the APIPortal.
func (o APIPortalSpecPtrOutput) Title() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIPortalSpec) *string {
		if v == nil {
			return nil
		}
		return v.Title
	}).(pulumi.StringPtrOutput)
}

// TrustedURLs are the urls that are trusted by the OAuth 2.0 authorization server.
func (o APIPortalSpecPtrOutput) TrustedUrls() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *APIPortalSpec) []string {
		if v == nil {
			return nil
		}
		return v.TrustedUrls
	}).(pulumi.StringArrayOutput)
}

// UI holds the UI customization options.
func (o APIPortalSpecPtrOutput) Ui() APIPortalSpecUiPtrOutput {
	return o.ApplyT(func(v *APIPortalSpec) *APIPortalSpecUi {
		if v == nil {
			return nil
		}
		return v.Ui
	}).(APIPortalSpecUiPtrOutput)
}

// UI holds the UI customization options.
type APIPortalSpecUi struct {
	// LogoURL is the public URL of the logo.
	LogoUrl *string `pulumi:"logoUrl"`
}

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

	ToAPIPortalSpecUiOutput() APIPortalSpecUiOutput
	ToAPIPortalSpecUiOutputWithContext(context.Context) APIPortalSpecUiOutput
}

// UI holds the UI customization options.
type APIPortalSpecUiArgs struct {
	// LogoURL is the public URL of the logo.
	LogoUrl pulumi.StringPtrInput `pulumi:"logoUrl"`
}

func (APIPortalSpecUiArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APIPortalSpecUi)(nil)).Elem()
}

func (i APIPortalSpecUiArgs) ToAPIPortalSpecUiOutput() APIPortalSpecUiOutput {
	return i.ToAPIPortalSpecUiOutputWithContext(context.Background())
}

func (i APIPortalSpecUiArgs) ToAPIPortalSpecUiOutputWithContext(ctx context.Context) APIPortalSpecUiOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIPortalSpecUiOutput)
}

func (i APIPortalSpecUiArgs) ToOutput(ctx context.Context) pulumix.Output[APIPortalSpecUi] {
	return pulumix.Output[APIPortalSpecUi]{
		OutputState: i.ToAPIPortalSpecUiOutputWithContext(ctx).OutputState,
	}
}

func (i APIPortalSpecUiArgs) ToAPIPortalSpecUiPtrOutput() APIPortalSpecUiPtrOutput {
	return i.ToAPIPortalSpecUiPtrOutputWithContext(context.Background())
}

func (i APIPortalSpecUiArgs) ToAPIPortalSpecUiPtrOutputWithContext(ctx context.Context) APIPortalSpecUiPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIPortalSpecUiOutput).ToAPIPortalSpecUiPtrOutputWithContext(ctx)
}

// APIPortalSpecUiPtrInput is an input type that accepts APIPortalSpecUiArgs, APIPortalSpecUiPtr and APIPortalSpecUiPtrOutput values.
// You can construct a concrete instance of `APIPortalSpecUiPtrInput` via:
//
//	        APIPortalSpecUiArgs{...}
//
//	or:
//
//	        nil
type APIPortalSpecUiPtrInput interface {
	pulumi.Input

	ToAPIPortalSpecUiPtrOutput() APIPortalSpecUiPtrOutput
	ToAPIPortalSpecUiPtrOutputWithContext(context.Context) APIPortalSpecUiPtrOutput
}

type apiportalSpecUiPtrType APIPortalSpecUiArgs

func APIPortalSpecUiPtr(v *APIPortalSpecUiArgs) APIPortalSpecUiPtrInput {
	return (*apiportalSpecUiPtrType)(v)
}

func (*apiportalSpecUiPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**APIPortalSpecUi)(nil)).Elem()
}

func (i *apiportalSpecUiPtrType) ToAPIPortalSpecUiPtrOutput() APIPortalSpecUiPtrOutput {
	return i.ToAPIPortalSpecUiPtrOutputWithContext(context.Background())
}

func (i *apiportalSpecUiPtrType) ToAPIPortalSpecUiPtrOutputWithContext(ctx context.Context) APIPortalSpecUiPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIPortalSpecUiPtrOutput)
}

func (i *apiportalSpecUiPtrType) ToOutput(ctx context.Context) pulumix.Output[*APIPortalSpecUi] {
	return pulumix.Output[*APIPortalSpecUi]{
		OutputState: i.ToAPIPortalSpecUiPtrOutputWithContext(ctx).OutputState,
	}
}

// UI holds the UI customization options.
type APIPortalSpecUiOutput struct{ *pulumi.OutputState }

func (APIPortalSpecUiOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APIPortalSpecUi)(nil)).Elem()
}

func (o APIPortalSpecUiOutput) ToAPIPortalSpecUiOutput() APIPortalSpecUiOutput {
	return o
}

func (o APIPortalSpecUiOutput) ToAPIPortalSpecUiOutputWithContext(ctx context.Context) APIPortalSpecUiOutput {
	return o
}

func (o APIPortalSpecUiOutput) ToAPIPortalSpecUiPtrOutput() APIPortalSpecUiPtrOutput {
	return o.ToAPIPortalSpecUiPtrOutputWithContext(context.Background())
}

func (o APIPortalSpecUiOutput) ToAPIPortalSpecUiPtrOutputWithContext(ctx context.Context) APIPortalSpecUiPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v APIPortalSpecUi) *APIPortalSpecUi {
		return &v
	}).(APIPortalSpecUiPtrOutput)
}

func (o APIPortalSpecUiOutput) ToOutput(ctx context.Context) pulumix.Output[APIPortalSpecUi] {
	return pulumix.Output[APIPortalSpecUi]{
		OutputState: o.OutputState,
	}
}

// LogoURL is the public URL of the logo.
func (o APIPortalSpecUiOutput) LogoUrl() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIPortalSpecUi) *string { return v.LogoUrl }).(pulumi.StringPtrOutput)
}

type APIPortalSpecUiPtrOutput struct{ *pulumi.OutputState }

func (APIPortalSpecUiPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**APIPortalSpecUi)(nil)).Elem()
}

func (o APIPortalSpecUiPtrOutput) ToAPIPortalSpecUiPtrOutput() APIPortalSpecUiPtrOutput {
	return o
}

func (o APIPortalSpecUiPtrOutput) ToAPIPortalSpecUiPtrOutputWithContext(ctx context.Context) APIPortalSpecUiPtrOutput {
	return o
}

func (o APIPortalSpecUiPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*APIPortalSpecUi] {
	return pulumix.Output[*APIPortalSpecUi]{
		OutputState: o.OutputState,
	}
}

func (o APIPortalSpecUiPtrOutput) Elem() APIPortalSpecUiOutput {
	return o.ApplyT(func(v *APIPortalSpecUi) APIPortalSpecUi {
		if v != nil {
			return *v
		}
		var ret APIPortalSpecUi
		return ret
	}).(APIPortalSpecUiOutput)
}

// LogoURL is the public URL of the logo.
func (o APIPortalSpecUiPtrOutput) LogoUrl() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIPortalSpecUi) *string {
		if v == nil {
			return nil
		}
		return v.LogoUrl
	}).(pulumi.StringPtrOutput)
}

// The current status of this APIPortal.
type APIPortalStatus struct {
	// Hash is a hash representing the APIPortal.
	Hash *string `pulumi:"hash"`
	// OIDC is the OIDC configuration for accessing the exposed APIPortal WebUI.
	Oidc     *APIPortalStatusOidc `pulumi:"oidc"`
	SyncedAt *string              `pulumi:"syncedAt"`
	Version  *string              `pulumi:"version"`
}

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

	ToAPIPortalStatusOutput() APIPortalStatusOutput
	ToAPIPortalStatusOutputWithContext(context.Context) APIPortalStatusOutput
}

// The current status of this APIPortal.
type APIPortalStatusArgs struct {
	// Hash is a hash representing the APIPortal.
	Hash pulumi.StringPtrInput `pulumi:"hash"`
	// OIDC is the OIDC configuration for accessing the exposed APIPortal WebUI.
	Oidc     APIPortalStatusOidcPtrInput `pulumi:"oidc"`
	SyncedAt pulumi.StringPtrInput       `pulumi:"syncedAt"`
	Version  pulumi.StringPtrInput       `pulumi:"version"`
}

func (APIPortalStatusArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APIPortalStatus)(nil)).Elem()
}

func (i APIPortalStatusArgs) ToAPIPortalStatusOutput() APIPortalStatusOutput {
	return i.ToAPIPortalStatusOutputWithContext(context.Background())
}

func (i APIPortalStatusArgs) ToAPIPortalStatusOutputWithContext(ctx context.Context) APIPortalStatusOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIPortalStatusOutput)
}

func (i APIPortalStatusArgs) ToOutput(ctx context.Context) pulumix.Output[APIPortalStatus] {
	return pulumix.Output[APIPortalStatus]{
		OutputState: i.ToAPIPortalStatusOutputWithContext(ctx).OutputState,
	}
}

func (i APIPortalStatusArgs) ToAPIPortalStatusPtrOutput() APIPortalStatusPtrOutput {
	return i.ToAPIPortalStatusPtrOutputWithContext(context.Background())
}

func (i APIPortalStatusArgs) ToAPIPortalStatusPtrOutputWithContext(ctx context.Context) APIPortalStatusPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIPortalStatusOutput).ToAPIPortalStatusPtrOutputWithContext(ctx)
}

// APIPortalStatusPtrInput is an input type that accepts APIPortalStatusArgs, APIPortalStatusPtr and APIPortalStatusPtrOutput values.
// You can construct a concrete instance of `APIPortalStatusPtrInput` via:
//
//	        APIPortalStatusArgs{...}
//
//	or:
//
//	        nil
type APIPortalStatusPtrInput interface {
	pulumi.Input

	ToAPIPortalStatusPtrOutput() APIPortalStatusPtrOutput
	ToAPIPortalStatusPtrOutputWithContext(context.Context) APIPortalStatusPtrOutput
}

type apiportalStatusPtrType APIPortalStatusArgs

func APIPortalStatusPtr(v *APIPortalStatusArgs) APIPortalStatusPtrInput {
	return (*apiportalStatusPtrType)(v)
}

func (*apiportalStatusPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**APIPortalStatus)(nil)).Elem()
}

func (i *apiportalStatusPtrType) ToAPIPortalStatusPtrOutput() APIPortalStatusPtrOutput {
	return i.ToAPIPortalStatusPtrOutputWithContext(context.Background())
}

func (i *apiportalStatusPtrType) ToAPIPortalStatusPtrOutputWithContext(ctx context.Context) APIPortalStatusPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIPortalStatusPtrOutput)
}

func (i *apiportalStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*APIPortalStatus] {
	return pulumix.Output[*APIPortalStatus]{
		OutputState: i.ToAPIPortalStatusPtrOutputWithContext(ctx).OutputState,
	}
}

// The current status of this APIPortal.
type APIPortalStatusOutput struct{ *pulumi.OutputState }

func (APIPortalStatusOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APIPortalStatus)(nil)).Elem()
}

func (o APIPortalStatusOutput) ToAPIPortalStatusOutput() APIPortalStatusOutput {
	return o
}

func (o APIPortalStatusOutput) ToAPIPortalStatusOutputWithContext(ctx context.Context) APIPortalStatusOutput {
	return o
}

func (o APIPortalStatusOutput) ToAPIPortalStatusPtrOutput() APIPortalStatusPtrOutput {
	return o.ToAPIPortalStatusPtrOutputWithContext(context.Background())
}

func (o APIPortalStatusOutput) ToAPIPortalStatusPtrOutputWithContext(ctx context.Context) APIPortalStatusPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v APIPortalStatus) *APIPortalStatus {
		return &v
	}).(APIPortalStatusPtrOutput)
}

func (o APIPortalStatusOutput) ToOutput(ctx context.Context) pulumix.Output[APIPortalStatus] {
	return pulumix.Output[APIPortalStatus]{
		OutputState: o.OutputState,
	}
}

// Hash is a hash representing the APIPortal.
func (o APIPortalStatusOutput) Hash() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIPortalStatus) *string { return v.Hash }).(pulumi.StringPtrOutput)
}

// OIDC is the OIDC configuration for accessing the exposed APIPortal WebUI.
func (o APIPortalStatusOutput) Oidc() APIPortalStatusOidcPtrOutput {
	return o.ApplyT(func(v APIPortalStatus) *APIPortalStatusOidc { return v.Oidc }).(APIPortalStatusOidcPtrOutput)
}

func (o APIPortalStatusOutput) SyncedAt() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIPortalStatus) *string { return v.SyncedAt }).(pulumi.StringPtrOutput)
}

func (o APIPortalStatusOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIPortalStatus) *string { return v.Version }).(pulumi.StringPtrOutput)
}

type APIPortalStatusPtrOutput struct{ *pulumi.OutputState }

func (APIPortalStatusPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**APIPortalStatus)(nil)).Elem()
}

func (o APIPortalStatusPtrOutput) ToAPIPortalStatusPtrOutput() APIPortalStatusPtrOutput {
	return o
}

func (o APIPortalStatusPtrOutput) ToAPIPortalStatusPtrOutputWithContext(ctx context.Context) APIPortalStatusPtrOutput {
	return o
}

func (o APIPortalStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*APIPortalStatus] {
	return pulumix.Output[*APIPortalStatus]{
		OutputState: o.OutputState,
	}
}

func (o APIPortalStatusPtrOutput) Elem() APIPortalStatusOutput {
	return o.ApplyT(func(v *APIPortalStatus) APIPortalStatus {
		if v != nil {
			return *v
		}
		var ret APIPortalStatus
		return ret
	}).(APIPortalStatusOutput)
}

// Hash is a hash representing the APIPortal.
func (o APIPortalStatusPtrOutput) Hash() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIPortalStatus) *string {
		if v == nil {
			return nil
		}
		return v.Hash
	}).(pulumi.StringPtrOutput)
}

// OIDC is the OIDC configuration for accessing the exposed APIPortal WebUI.
func (o APIPortalStatusPtrOutput) Oidc() APIPortalStatusOidcPtrOutput {
	return o.ApplyT(func(v *APIPortalStatus) *APIPortalStatusOidc {
		if v == nil {
			return nil
		}
		return v.Oidc
	}).(APIPortalStatusOidcPtrOutput)
}

func (o APIPortalStatusPtrOutput) SyncedAt() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIPortalStatus) *string {
		if v == nil {
			return nil
		}
		return v.SyncedAt
	}).(pulumi.StringPtrOutput)
}

func (o APIPortalStatusPtrOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIPortalStatus) *string {
		if v == nil {
			return nil
		}
		return v.Version
	}).(pulumi.StringPtrOutput)
}

// OIDC is the OIDC configuration for accessing the exposed APIPortal WebUI.
type APIPortalStatusOidc struct {
	// ClientID is the OIDC ClientID for accessing the exposed APIPortal WebUI.
	ClientId *string `pulumi:"clientId"`
	// CompanyClaim is the name of the JWT claim containing the user company.
	CompanyClaim *string `pulumi:"companyClaim"`
	// EmailClaim is the name of the JWT claim containing the user email.
	EmailClaim *string `pulumi:"emailClaim"`
	// FirstnameClaim is the name of the JWT claim containing the user firstname.
	FirstnameClaim *string `pulumi:"firstnameClaim"`
	// Generic indicates whether or not the APIPortal authentication relies on Generic OIDC.
	Generic *bool `pulumi:"generic"`
	// GroupsClaim is the name of the JWT claim containing the user groups.
	GroupsClaim *string `pulumi:"groupsClaim"`
	// Issuer is the OIDC issuer for accessing the exposed APIPortal WebUI.
	Issuer *string `pulumi:"issuer"`
	// LastnameClaim is the name of the JWT claim containing the user lastname.
	LastnameClaim *string `pulumi:"lastnameClaim"`
	// Scopes is the OIDC scopes for getting user attributes during the authentication to the exposed APIPortal WebUI.
	Scopes *string `pulumi:"scopes"`
	// SecretName is the name of the secret containing the OIDC ClientSecret for accessing the exposed APIPortal WebUI.
	SecretName *string `pulumi:"secretName"`
	// SyncedAttributes configure the user attributes to sync.
	SyncedAttributes []string `pulumi:"syncedAttributes"`
	// UserIDClaim is the name of the JWT claim containing the user ID.
	UserIdClaim *string `pulumi:"userIdClaim"`
}

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

	ToAPIPortalStatusOidcOutput() APIPortalStatusOidcOutput
	ToAPIPortalStatusOidcOutputWithContext(context.Context) APIPortalStatusOidcOutput
}

// OIDC is the OIDC configuration for accessing the exposed APIPortal WebUI.
type APIPortalStatusOidcArgs struct {
	// ClientID is the OIDC ClientID for accessing the exposed APIPortal WebUI.
	ClientId pulumi.StringPtrInput `pulumi:"clientId"`
	// CompanyClaim is the name of the JWT claim containing the user company.
	CompanyClaim pulumi.StringPtrInput `pulumi:"companyClaim"`
	// EmailClaim is the name of the JWT claim containing the user email.
	EmailClaim pulumi.StringPtrInput `pulumi:"emailClaim"`
	// FirstnameClaim is the name of the JWT claim containing the user firstname.
	FirstnameClaim pulumi.StringPtrInput `pulumi:"firstnameClaim"`
	// Generic indicates whether or not the APIPortal authentication relies on Generic OIDC.
	Generic pulumi.BoolPtrInput `pulumi:"generic"`
	// GroupsClaim is the name of the JWT claim containing the user groups.
	GroupsClaim pulumi.StringPtrInput `pulumi:"groupsClaim"`
	// Issuer is the OIDC issuer for accessing the exposed APIPortal WebUI.
	Issuer pulumi.StringPtrInput `pulumi:"issuer"`
	// LastnameClaim is the name of the JWT claim containing the user lastname.
	LastnameClaim pulumi.StringPtrInput `pulumi:"lastnameClaim"`
	// Scopes is the OIDC scopes for getting user attributes during the authentication to the exposed APIPortal WebUI.
	Scopes pulumi.StringPtrInput `pulumi:"scopes"`
	// SecretName is the name of the secret containing the OIDC ClientSecret for accessing the exposed APIPortal WebUI.
	SecretName pulumi.StringPtrInput `pulumi:"secretName"`
	// SyncedAttributes configure the user attributes to sync.
	SyncedAttributes pulumi.StringArrayInput `pulumi:"syncedAttributes"`
	// UserIDClaim is the name of the JWT claim containing the user ID.
	UserIdClaim pulumi.StringPtrInput `pulumi:"userIdClaim"`
}

func (APIPortalStatusOidcArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APIPortalStatusOidc)(nil)).Elem()
}

func (i APIPortalStatusOidcArgs) ToAPIPortalStatusOidcOutput() APIPortalStatusOidcOutput {
	return i.ToAPIPortalStatusOidcOutputWithContext(context.Background())
}

func (i APIPortalStatusOidcArgs) ToAPIPortalStatusOidcOutputWithContext(ctx context.Context) APIPortalStatusOidcOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIPortalStatusOidcOutput)
}

func (i APIPortalStatusOidcArgs) ToOutput(ctx context.Context) pulumix.Output[APIPortalStatusOidc] {
	return pulumix.Output[APIPortalStatusOidc]{
		OutputState: i.ToAPIPortalStatusOidcOutputWithContext(ctx).OutputState,
	}
}

func (i APIPortalStatusOidcArgs) ToAPIPortalStatusOidcPtrOutput() APIPortalStatusOidcPtrOutput {
	return i.ToAPIPortalStatusOidcPtrOutputWithContext(context.Background())
}

func (i APIPortalStatusOidcArgs) ToAPIPortalStatusOidcPtrOutputWithContext(ctx context.Context) APIPortalStatusOidcPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIPortalStatusOidcOutput).ToAPIPortalStatusOidcPtrOutputWithContext(ctx)
}

// APIPortalStatusOidcPtrInput is an input type that accepts APIPortalStatusOidcArgs, APIPortalStatusOidcPtr and APIPortalStatusOidcPtrOutput values.
// You can construct a concrete instance of `APIPortalStatusOidcPtrInput` via:
//
//	        APIPortalStatusOidcArgs{...}
//
//	or:
//
//	        nil
type APIPortalStatusOidcPtrInput interface {
	pulumi.Input

	ToAPIPortalStatusOidcPtrOutput() APIPortalStatusOidcPtrOutput
	ToAPIPortalStatusOidcPtrOutputWithContext(context.Context) APIPortalStatusOidcPtrOutput
}

type apiportalStatusOidcPtrType APIPortalStatusOidcArgs

func APIPortalStatusOidcPtr(v *APIPortalStatusOidcArgs) APIPortalStatusOidcPtrInput {
	return (*apiportalStatusOidcPtrType)(v)
}

func (*apiportalStatusOidcPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**APIPortalStatusOidc)(nil)).Elem()
}

func (i *apiportalStatusOidcPtrType) ToAPIPortalStatusOidcPtrOutput() APIPortalStatusOidcPtrOutput {
	return i.ToAPIPortalStatusOidcPtrOutputWithContext(context.Background())
}

func (i *apiportalStatusOidcPtrType) ToAPIPortalStatusOidcPtrOutputWithContext(ctx context.Context) APIPortalStatusOidcPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIPortalStatusOidcPtrOutput)
}

func (i *apiportalStatusOidcPtrType) ToOutput(ctx context.Context) pulumix.Output[*APIPortalStatusOidc] {
	return pulumix.Output[*APIPortalStatusOidc]{
		OutputState: i.ToAPIPortalStatusOidcPtrOutputWithContext(ctx).OutputState,
	}
}

// OIDC is the OIDC configuration for accessing the exposed APIPortal WebUI.
type APIPortalStatusOidcOutput struct{ *pulumi.OutputState }

func (APIPortalStatusOidcOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APIPortalStatusOidc)(nil)).Elem()
}

func (o APIPortalStatusOidcOutput) ToAPIPortalStatusOidcOutput() APIPortalStatusOidcOutput {
	return o
}

func (o APIPortalStatusOidcOutput) ToAPIPortalStatusOidcOutputWithContext(ctx context.Context) APIPortalStatusOidcOutput {
	return o
}

func (o APIPortalStatusOidcOutput) ToAPIPortalStatusOidcPtrOutput() APIPortalStatusOidcPtrOutput {
	return o.ToAPIPortalStatusOidcPtrOutputWithContext(context.Background())
}

func (o APIPortalStatusOidcOutput) ToAPIPortalStatusOidcPtrOutputWithContext(ctx context.Context) APIPortalStatusOidcPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v APIPortalStatusOidc) *APIPortalStatusOidc {
		return &v
	}).(APIPortalStatusOidcPtrOutput)
}

func (o APIPortalStatusOidcOutput) ToOutput(ctx context.Context) pulumix.Output[APIPortalStatusOidc] {
	return pulumix.Output[APIPortalStatusOidc]{
		OutputState: o.OutputState,
	}
}

// ClientID is the OIDC ClientID for accessing the exposed APIPortal WebUI.
func (o APIPortalStatusOidcOutput) ClientId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIPortalStatusOidc) *string { return v.ClientId }).(pulumi.StringPtrOutput)
}

// CompanyClaim is the name of the JWT claim containing the user company.
func (o APIPortalStatusOidcOutput) CompanyClaim() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIPortalStatusOidc) *string { return v.CompanyClaim }).(pulumi.StringPtrOutput)
}

// EmailClaim is the name of the JWT claim containing the user email.
func (o APIPortalStatusOidcOutput) EmailClaim() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIPortalStatusOidc) *string { return v.EmailClaim }).(pulumi.StringPtrOutput)
}

// FirstnameClaim is the name of the JWT claim containing the user firstname.
func (o APIPortalStatusOidcOutput) FirstnameClaim() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIPortalStatusOidc) *string { return v.FirstnameClaim }).(pulumi.StringPtrOutput)
}

// Generic indicates whether or not the APIPortal authentication relies on Generic OIDC.
func (o APIPortalStatusOidcOutput) Generic() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v APIPortalStatusOidc) *bool { return v.Generic }).(pulumi.BoolPtrOutput)
}

// GroupsClaim is the name of the JWT claim containing the user groups.
func (o APIPortalStatusOidcOutput) GroupsClaim() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIPortalStatusOidc) *string { return v.GroupsClaim }).(pulumi.StringPtrOutput)
}

// Issuer is the OIDC issuer for accessing the exposed APIPortal WebUI.
func (o APIPortalStatusOidcOutput) Issuer() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIPortalStatusOidc) *string { return v.Issuer }).(pulumi.StringPtrOutput)
}

// LastnameClaim is the name of the JWT claim containing the user lastname.
func (o APIPortalStatusOidcOutput) LastnameClaim() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIPortalStatusOidc) *string { return v.LastnameClaim }).(pulumi.StringPtrOutput)
}

// Scopes is the OIDC scopes for getting user attributes during the authentication to the exposed APIPortal WebUI.
func (o APIPortalStatusOidcOutput) Scopes() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIPortalStatusOidc) *string { return v.Scopes }).(pulumi.StringPtrOutput)
}

// SecretName is the name of the secret containing the OIDC ClientSecret for accessing the exposed APIPortal WebUI.
func (o APIPortalStatusOidcOutput) SecretName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIPortalStatusOidc) *string { return v.SecretName }).(pulumi.StringPtrOutput)
}

// SyncedAttributes configure the user attributes to sync.
func (o APIPortalStatusOidcOutput) SyncedAttributes() pulumi.StringArrayOutput {
	return o.ApplyT(func(v APIPortalStatusOidc) []string { return v.SyncedAttributes }).(pulumi.StringArrayOutput)
}

// UserIDClaim is the name of the JWT claim containing the user ID.
func (o APIPortalStatusOidcOutput) UserIdClaim() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIPortalStatusOidc) *string { return v.UserIdClaim }).(pulumi.StringPtrOutput)
}

type APIPortalStatusOidcPtrOutput struct{ *pulumi.OutputState }

func (APIPortalStatusOidcPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**APIPortalStatusOidc)(nil)).Elem()
}

func (o APIPortalStatusOidcPtrOutput) ToAPIPortalStatusOidcPtrOutput() APIPortalStatusOidcPtrOutput {
	return o
}

func (o APIPortalStatusOidcPtrOutput) ToAPIPortalStatusOidcPtrOutputWithContext(ctx context.Context) APIPortalStatusOidcPtrOutput {
	return o
}

func (o APIPortalStatusOidcPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*APIPortalStatusOidc] {
	return pulumix.Output[*APIPortalStatusOidc]{
		OutputState: o.OutputState,
	}
}

func (o APIPortalStatusOidcPtrOutput) Elem() APIPortalStatusOidcOutput {
	return o.ApplyT(func(v *APIPortalStatusOidc) APIPortalStatusOidc {
		if v != nil {
			return *v
		}
		var ret APIPortalStatusOidc
		return ret
	}).(APIPortalStatusOidcOutput)
}

// ClientID is the OIDC ClientID for accessing the exposed APIPortal WebUI.
func (o APIPortalStatusOidcPtrOutput) ClientId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIPortalStatusOidc) *string {
		if v == nil {
			return nil
		}
		return v.ClientId
	}).(pulumi.StringPtrOutput)
}

// CompanyClaim is the name of the JWT claim containing the user company.
func (o APIPortalStatusOidcPtrOutput) CompanyClaim() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIPortalStatusOidc) *string {
		if v == nil {
			return nil
		}
		return v.CompanyClaim
	}).(pulumi.StringPtrOutput)
}

// EmailClaim is the name of the JWT claim containing the user email.
func (o APIPortalStatusOidcPtrOutput) EmailClaim() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIPortalStatusOidc) *string {
		if v == nil {
			return nil
		}
		return v.EmailClaim
	}).(pulumi.StringPtrOutput)
}

// FirstnameClaim is the name of the JWT claim containing the user firstname.
func (o APIPortalStatusOidcPtrOutput) FirstnameClaim() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIPortalStatusOidc) *string {
		if v == nil {
			return nil
		}
		return v.FirstnameClaim
	}).(pulumi.StringPtrOutput)
}

// Generic indicates whether or not the APIPortal authentication relies on Generic OIDC.
func (o APIPortalStatusOidcPtrOutput) Generic() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *APIPortalStatusOidc) *bool {
		if v == nil {
			return nil
		}
		return v.Generic
	}).(pulumi.BoolPtrOutput)
}

// GroupsClaim is the name of the JWT claim containing the user groups.
func (o APIPortalStatusOidcPtrOutput) GroupsClaim() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIPortalStatusOidc) *string {
		if v == nil {
			return nil
		}
		return v.GroupsClaim
	}).(pulumi.StringPtrOutput)
}

// Issuer is the OIDC issuer for accessing the exposed APIPortal WebUI.
func (o APIPortalStatusOidcPtrOutput) Issuer() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIPortalStatusOidc) *string {
		if v == nil {
			return nil
		}
		return v.Issuer
	}).(pulumi.StringPtrOutput)
}

// LastnameClaim is the name of the JWT claim containing the user lastname.
func (o APIPortalStatusOidcPtrOutput) LastnameClaim() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIPortalStatusOidc) *string {
		if v == nil {
			return nil
		}
		return v.LastnameClaim
	}).(pulumi.StringPtrOutput)
}

// Scopes is the OIDC scopes for getting user attributes during the authentication to the exposed APIPortal WebUI.
func (o APIPortalStatusOidcPtrOutput) Scopes() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIPortalStatusOidc) *string {
		if v == nil {
			return nil
		}
		return v.Scopes
	}).(pulumi.StringPtrOutput)
}

// SecretName is the name of the secret containing the OIDC ClientSecret for accessing the exposed APIPortal WebUI.
func (o APIPortalStatusOidcPtrOutput) SecretName() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIPortalStatusOidc) *string {
		if v == nil {
			return nil
		}
		return v.SecretName
	}).(pulumi.StringPtrOutput)
}

// SyncedAttributes configure the user attributes to sync.
func (o APIPortalStatusOidcPtrOutput) SyncedAttributes() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *APIPortalStatusOidc) []string {
		if v == nil {
			return nil
		}
		return v.SyncedAttributes
	}).(pulumi.StringArrayOutput)
}

// UserIDClaim is the name of the JWT claim containing the user ID.
func (o APIPortalStatusOidcPtrOutput) UserIdClaim() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIPortalStatusOidc) *string {
		if v == nil {
			return nil
		}
		return v.UserIdClaim
	}).(pulumi.StringPtrOutput)
}

// APIRateLimit defines how group of consumers are rate limited on a set of APIs.
type APIRateLimitType struct {
	ApiVersion *string        `pulumi:"apiVersion"`
	Kind       *string        `pulumi:"kind"`
	Metadata   *v1.ObjectMeta `pulumi:"metadata"`
	// The desired behavior of this APIRateLimit.
	Spec *APIRateLimitSpec `pulumi:"spec"`
	// The current status of this APIRateLimit.
	Status *APIRateLimitStatus `pulumi:"status"`
}

type APIRateLimitMetadata struct {
}

// The desired behavior of this APIRateLimit.
type APIRateLimitSpec struct {
	// APISelector selects the APIs that will be rate limited.
	// Multiple APIRateLimits can select the same set of APIs.
	// This field is optional and follows standard label selector semantics.
	// An empty APISelector matches any API.
	ApiSelector *APIRateLimitSpecApiSelector `pulumi:"apiSelector"`
	// APIs defines a set of APIs that will be rate limited.
	// Multiple APIRateLimits can select the same APIs.
	// When combined with APISelector, this set of APIs is appended to the matching APIs.
	Apis []APIRateLimitSpecApis `pulumi:"apis"`
	// Everyone indicates that all users will, by default, be rate limited with this configuration.
	// If an APIRateLimit explicitly target a group, the default rate limit will be ignored.
	Everyone *bool `pulumi:"everyone"`
	// Groups are the consumer groups that will be rate limited.
	// Multiple APIRateLimits can target the same set of consumer groups, the most restrictive one applies.
	// When a consumer belongs to multiple groups, the least restrictive APIRateLimit applies.
	Groups []string `pulumi:"groups"`
	// Limit is the maximum number of token in the bucket.
	Limit int `pulumi:"limit"`
	// Period is the unit of time for the Limit.
	Period *string `pulumi:"period"`
	// Strategy defines how the bucket state will be synchronized between the different Traefik Hub instances.
	// It can be, either "local" or "distributed".
	Strategy *string `pulumi:"strategy"`
}

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

	ToAPIRateLimitSpecOutput() APIRateLimitSpecOutput
	ToAPIRateLimitSpecOutputWithContext(context.Context) APIRateLimitSpecOutput
}

// The desired behavior of this APIRateLimit.
type APIRateLimitSpecArgs struct {
	// APISelector selects the APIs that will be rate limited.
	// Multiple APIRateLimits can select the same set of APIs.
	// This field is optional and follows standard label selector semantics.
	// An empty APISelector matches any API.
	ApiSelector APIRateLimitSpecApiSelectorPtrInput `pulumi:"apiSelector"`
	// APIs defines a set of APIs that will be rate limited.
	// Multiple APIRateLimits can select the same APIs.
	// When combined with APISelector, this set of APIs is appended to the matching APIs.
	Apis APIRateLimitSpecApisArrayInput `pulumi:"apis"`
	// Everyone indicates that all users will, by default, be rate limited with this configuration.
	// If an APIRateLimit explicitly target a group, the default rate limit will be ignored.
	Everyone pulumi.BoolPtrInput `pulumi:"everyone"`
	// Groups are the consumer groups that will be rate limited.
	// Multiple APIRateLimits can target the same set of consumer groups, the most restrictive one applies.
	// When a consumer belongs to multiple groups, the least restrictive APIRateLimit applies.
	Groups pulumi.StringArrayInput `pulumi:"groups"`
	// Limit is the maximum number of token in the bucket.
	Limit pulumi.IntInput `pulumi:"limit"`
	// Period is the unit of time for the Limit.
	Period pulumi.StringPtrInput `pulumi:"period"`
	// Strategy defines how the bucket state will be synchronized between the different Traefik Hub instances.
	// It can be, either "local" or "distributed".
	Strategy pulumi.StringPtrInput `pulumi:"strategy"`
}

func (APIRateLimitSpecArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APIRateLimitSpec)(nil)).Elem()
}

func (i APIRateLimitSpecArgs) ToAPIRateLimitSpecOutput() APIRateLimitSpecOutput {
	return i.ToAPIRateLimitSpecOutputWithContext(context.Background())
}

func (i APIRateLimitSpecArgs) ToAPIRateLimitSpecOutputWithContext(ctx context.Context) APIRateLimitSpecOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIRateLimitSpecOutput)
}

func (i APIRateLimitSpecArgs) ToOutput(ctx context.Context) pulumix.Output[APIRateLimitSpec] {
	return pulumix.Output[APIRateLimitSpec]{
		OutputState: i.ToAPIRateLimitSpecOutputWithContext(ctx).OutputState,
	}
}

func (i APIRateLimitSpecArgs) ToAPIRateLimitSpecPtrOutput() APIRateLimitSpecPtrOutput {
	return i.ToAPIRateLimitSpecPtrOutputWithContext(context.Background())
}

func (i APIRateLimitSpecArgs) ToAPIRateLimitSpecPtrOutputWithContext(ctx context.Context) APIRateLimitSpecPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIRateLimitSpecOutput).ToAPIRateLimitSpecPtrOutputWithContext(ctx)
}

// APIRateLimitSpecPtrInput is an input type that accepts APIRateLimitSpecArgs, APIRateLimitSpecPtr and APIRateLimitSpecPtrOutput values.
// You can construct a concrete instance of `APIRateLimitSpecPtrInput` via:
//
//	        APIRateLimitSpecArgs{...}
//
//	or:
//
//	        nil
type APIRateLimitSpecPtrInput interface {
	pulumi.Input

	ToAPIRateLimitSpecPtrOutput() APIRateLimitSpecPtrOutput
	ToAPIRateLimitSpecPtrOutputWithContext(context.Context) APIRateLimitSpecPtrOutput
}

type apirateLimitSpecPtrType APIRateLimitSpecArgs

func APIRateLimitSpecPtr(v *APIRateLimitSpecArgs) APIRateLimitSpecPtrInput {
	return (*apirateLimitSpecPtrType)(v)
}

func (*apirateLimitSpecPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**APIRateLimitSpec)(nil)).Elem()
}

func (i *apirateLimitSpecPtrType) ToAPIRateLimitSpecPtrOutput() APIRateLimitSpecPtrOutput {
	return i.ToAPIRateLimitSpecPtrOutputWithContext(context.Background())
}

func (i *apirateLimitSpecPtrType) ToAPIRateLimitSpecPtrOutputWithContext(ctx context.Context) APIRateLimitSpecPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIRateLimitSpecPtrOutput)
}

func (i *apirateLimitSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*APIRateLimitSpec] {
	return pulumix.Output[*APIRateLimitSpec]{
		OutputState: i.ToAPIRateLimitSpecPtrOutputWithContext(ctx).OutputState,
	}
}

// The desired behavior of this APIRateLimit.
type APIRateLimitSpecOutput struct{ *pulumi.OutputState }

func (APIRateLimitSpecOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APIRateLimitSpec)(nil)).Elem()
}

func (o APIRateLimitSpecOutput) ToAPIRateLimitSpecOutput() APIRateLimitSpecOutput {
	return o
}

func (o APIRateLimitSpecOutput) ToAPIRateLimitSpecOutputWithContext(ctx context.Context) APIRateLimitSpecOutput {
	return o
}

func (o APIRateLimitSpecOutput) ToAPIRateLimitSpecPtrOutput() APIRateLimitSpecPtrOutput {
	return o.ToAPIRateLimitSpecPtrOutputWithContext(context.Background())
}

func (o APIRateLimitSpecOutput) ToAPIRateLimitSpecPtrOutputWithContext(ctx context.Context) APIRateLimitSpecPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v APIRateLimitSpec) *APIRateLimitSpec {
		return &v
	}).(APIRateLimitSpecPtrOutput)
}

func (o APIRateLimitSpecOutput) ToOutput(ctx context.Context) pulumix.Output[APIRateLimitSpec] {
	return pulumix.Output[APIRateLimitSpec]{
		OutputState: o.OutputState,
	}
}

// APISelector selects the APIs that will be rate limited.
// Multiple APIRateLimits can select the same set of APIs.
// This field is optional and follows standard label selector semantics.
// An empty APISelector matches any API.
func (o APIRateLimitSpecOutput) ApiSelector() APIRateLimitSpecApiSelectorPtrOutput {
	return o.ApplyT(func(v APIRateLimitSpec) *APIRateLimitSpecApiSelector { return v.ApiSelector }).(APIRateLimitSpecApiSelectorPtrOutput)
}

// APIs defines a set of APIs that will be rate limited.
// Multiple APIRateLimits can select the same APIs.
// When combined with APISelector, this set of APIs is appended to the matching APIs.
func (o APIRateLimitSpecOutput) Apis() APIRateLimitSpecApisArrayOutput {
	return o.ApplyT(func(v APIRateLimitSpec) []APIRateLimitSpecApis { return v.Apis }).(APIRateLimitSpecApisArrayOutput)
}

// Everyone indicates that all users will, by default, be rate limited with this configuration.
// If an APIRateLimit explicitly target a group, the default rate limit will be ignored.
func (o APIRateLimitSpecOutput) Everyone() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v APIRateLimitSpec) *bool { return v.Everyone }).(pulumi.BoolPtrOutput)
}

// Groups are the consumer groups that will be rate limited.
// Multiple APIRateLimits can target the same set of consumer groups, the most restrictive one applies.
// When a consumer belongs to multiple groups, the least restrictive APIRateLimit applies.
func (o APIRateLimitSpecOutput) Groups() pulumi.StringArrayOutput {
	return o.ApplyT(func(v APIRateLimitSpec) []string { return v.Groups }).(pulumi.StringArrayOutput)
}

// Limit is the maximum number of token in the bucket.
func (o APIRateLimitSpecOutput) Limit() pulumi.IntOutput {
	return o.ApplyT(func(v APIRateLimitSpec) int { return v.Limit }).(pulumi.IntOutput)
}

// Period is the unit of time for the Limit.
func (o APIRateLimitSpecOutput) Period() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIRateLimitSpec) *string { return v.Period }).(pulumi.StringPtrOutput)
}

// Strategy defines how the bucket state will be synchronized between the different Traefik Hub instances.
// It can be, either "local" or "distributed".
func (o APIRateLimitSpecOutput) Strategy() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIRateLimitSpec) *string { return v.Strategy }).(pulumi.StringPtrOutput)
}

type APIRateLimitSpecPtrOutput struct{ *pulumi.OutputState }

func (APIRateLimitSpecPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**APIRateLimitSpec)(nil)).Elem()
}

func (o APIRateLimitSpecPtrOutput) ToAPIRateLimitSpecPtrOutput() APIRateLimitSpecPtrOutput {
	return o
}

func (o APIRateLimitSpecPtrOutput) ToAPIRateLimitSpecPtrOutputWithContext(ctx context.Context) APIRateLimitSpecPtrOutput {
	return o
}

func (o APIRateLimitSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*APIRateLimitSpec] {
	return pulumix.Output[*APIRateLimitSpec]{
		OutputState: o.OutputState,
	}
}

func (o APIRateLimitSpecPtrOutput) Elem() APIRateLimitSpecOutput {
	return o.ApplyT(func(v *APIRateLimitSpec) APIRateLimitSpec {
		if v != nil {
			return *v
		}
		var ret APIRateLimitSpec
		return ret
	}).(APIRateLimitSpecOutput)
}

// APISelector selects the APIs that will be rate limited.
// Multiple APIRateLimits can select the same set of APIs.
// This field is optional and follows standard label selector semantics.
// An empty APISelector matches any API.
func (o APIRateLimitSpecPtrOutput) ApiSelector() APIRateLimitSpecApiSelectorPtrOutput {
	return o.ApplyT(func(v *APIRateLimitSpec) *APIRateLimitSpecApiSelector {
		if v == nil {
			return nil
		}
		return v.ApiSelector
	}).(APIRateLimitSpecApiSelectorPtrOutput)
}

// APIs defines a set of APIs that will be rate limited.
// Multiple APIRateLimits can select the same APIs.
// When combined with APISelector, this set of APIs is appended to the matching APIs.
func (o APIRateLimitSpecPtrOutput) Apis() APIRateLimitSpecApisArrayOutput {
	return o.ApplyT(func(v *APIRateLimitSpec) []APIRateLimitSpecApis {
		if v == nil {
			return nil
		}
		return v.Apis
	}).(APIRateLimitSpecApisArrayOutput)
}

// Everyone indicates that all users will, by default, be rate limited with this configuration.
// If an APIRateLimit explicitly target a group, the default rate limit will be ignored.
func (o APIRateLimitSpecPtrOutput) Everyone() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *APIRateLimitSpec) *bool {
		if v == nil {
			return nil
		}
		return v.Everyone
	}).(pulumi.BoolPtrOutput)
}

// Groups are the consumer groups that will be rate limited.
// Multiple APIRateLimits can target the same set of consumer groups, the most restrictive one applies.
// When a consumer belongs to multiple groups, the least restrictive APIRateLimit applies.
func (o APIRateLimitSpecPtrOutput) Groups() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *APIRateLimitSpec) []string {
		if v == nil {
			return nil
		}
		return v.Groups
	}).(pulumi.StringArrayOutput)
}

// Limit is the maximum number of token in the bucket.
func (o APIRateLimitSpecPtrOutput) Limit() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *APIRateLimitSpec) *int {
		if v == nil {
			return nil
		}
		return &v.Limit
	}).(pulumi.IntPtrOutput)
}

// Period is the unit of time for the Limit.
func (o APIRateLimitSpecPtrOutput) Period() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIRateLimitSpec) *string {
		if v == nil {
			return nil
		}
		return v.Period
	}).(pulumi.StringPtrOutput)
}

// Strategy defines how the bucket state will be synchronized between the different Traefik Hub instances.
// It can be, either "local" or "distributed".
func (o APIRateLimitSpecPtrOutput) Strategy() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIRateLimitSpec) *string {
		if v == nil {
			return nil
		}
		return v.Strategy
	}).(pulumi.StringPtrOutput)
}

// APISelector selects the APIs that will be rate limited.
// Multiple APIRateLimits can select the same set of APIs.
// This field is optional and follows standard label selector semantics.
// An empty APISelector matches any API.
type APIRateLimitSpecApiSelector struct {
	// matchExpressions is a list of label selector requirements. The requirements are ANDed.
	MatchExpressions []APIRateLimitSpecApiSelectorMatchExpressions `pulumi:"matchExpressions"`
	// matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
	// map is equivalent to an element of matchExpressions, whose key field is "key", the
	// operator is "In", and the values array contains only "value". The requirements are ANDed.
	MatchLabels map[string]string `pulumi:"matchLabels"`
}

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

	ToAPIRateLimitSpecApiSelectorOutput() APIRateLimitSpecApiSelectorOutput
	ToAPIRateLimitSpecApiSelectorOutputWithContext(context.Context) APIRateLimitSpecApiSelectorOutput
}

// APISelector selects the APIs that will be rate limited.
// Multiple APIRateLimits can select the same set of APIs.
// This field is optional and follows standard label selector semantics.
// An empty APISelector matches any API.
type APIRateLimitSpecApiSelectorArgs struct {
	// matchExpressions is a list of label selector requirements. The requirements are ANDed.
	MatchExpressions APIRateLimitSpecApiSelectorMatchExpressionsArrayInput `pulumi:"matchExpressions"`
	// matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
	// map is equivalent to an element of matchExpressions, whose key field is "key", the
	// operator is "In", and the values array contains only "value". The requirements are ANDed.
	MatchLabels pulumi.StringMapInput `pulumi:"matchLabels"`
}

func (APIRateLimitSpecApiSelectorArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APIRateLimitSpecApiSelector)(nil)).Elem()
}

func (i APIRateLimitSpecApiSelectorArgs) ToAPIRateLimitSpecApiSelectorOutput() APIRateLimitSpecApiSelectorOutput {
	return i.ToAPIRateLimitSpecApiSelectorOutputWithContext(context.Background())
}

func (i APIRateLimitSpecApiSelectorArgs) ToAPIRateLimitSpecApiSelectorOutputWithContext(ctx context.Context) APIRateLimitSpecApiSelectorOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIRateLimitSpecApiSelectorOutput)
}

func (i APIRateLimitSpecApiSelectorArgs) ToOutput(ctx context.Context) pulumix.Output[APIRateLimitSpecApiSelector] {
	return pulumix.Output[APIRateLimitSpecApiSelector]{
		OutputState: i.ToAPIRateLimitSpecApiSelectorOutputWithContext(ctx).OutputState,
	}
}

func (i APIRateLimitSpecApiSelectorArgs) ToAPIRateLimitSpecApiSelectorPtrOutput() APIRateLimitSpecApiSelectorPtrOutput {
	return i.ToAPIRateLimitSpecApiSelectorPtrOutputWithContext(context.Background())
}

func (i APIRateLimitSpecApiSelectorArgs) ToAPIRateLimitSpecApiSelectorPtrOutputWithContext(ctx context.Context) APIRateLimitSpecApiSelectorPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIRateLimitSpecApiSelectorOutput).ToAPIRateLimitSpecApiSelectorPtrOutputWithContext(ctx)
}

// APIRateLimitSpecApiSelectorPtrInput is an input type that accepts APIRateLimitSpecApiSelectorArgs, APIRateLimitSpecApiSelectorPtr and APIRateLimitSpecApiSelectorPtrOutput values.
// You can construct a concrete instance of `APIRateLimitSpecApiSelectorPtrInput` via:
//
//	        APIRateLimitSpecApiSelectorArgs{...}
//
//	or:
//
//	        nil
type APIRateLimitSpecApiSelectorPtrInput interface {
	pulumi.Input

	ToAPIRateLimitSpecApiSelectorPtrOutput() APIRateLimitSpecApiSelectorPtrOutput
	ToAPIRateLimitSpecApiSelectorPtrOutputWithContext(context.Context) APIRateLimitSpecApiSelectorPtrOutput
}

type apirateLimitSpecApiSelectorPtrType APIRateLimitSpecApiSelectorArgs

func APIRateLimitSpecApiSelectorPtr(v *APIRateLimitSpecApiSelectorArgs) APIRateLimitSpecApiSelectorPtrInput {
	return (*apirateLimitSpecApiSelectorPtrType)(v)
}

func (*apirateLimitSpecApiSelectorPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**APIRateLimitSpecApiSelector)(nil)).Elem()
}

func (i *apirateLimitSpecApiSelectorPtrType) ToAPIRateLimitSpecApiSelectorPtrOutput() APIRateLimitSpecApiSelectorPtrOutput {
	return i.ToAPIRateLimitSpecApiSelectorPtrOutputWithContext(context.Background())
}

func (i *apirateLimitSpecApiSelectorPtrType) ToAPIRateLimitSpecApiSelectorPtrOutputWithContext(ctx context.Context) APIRateLimitSpecApiSelectorPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIRateLimitSpecApiSelectorPtrOutput)
}

func (i *apirateLimitSpecApiSelectorPtrType) ToOutput(ctx context.Context) pulumix.Output[*APIRateLimitSpecApiSelector] {
	return pulumix.Output[*APIRateLimitSpecApiSelector]{
		OutputState: i.ToAPIRateLimitSpecApiSelectorPtrOutputWithContext(ctx).OutputState,
	}
}

// APISelector selects the APIs that will be rate limited.
// Multiple APIRateLimits can select the same set of APIs.
// This field is optional and follows standard label selector semantics.
// An empty APISelector matches any API.
type APIRateLimitSpecApiSelectorOutput struct{ *pulumi.OutputState }

func (APIRateLimitSpecApiSelectorOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APIRateLimitSpecApiSelector)(nil)).Elem()
}

func (o APIRateLimitSpecApiSelectorOutput) ToAPIRateLimitSpecApiSelectorOutput() APIRateLimitSpecApiSelectorOutput {
	return o
}

func (o APIRateLimitSpecApiSelectorOutput) ToAPIRateLimitSpecApiSelectorOutputWithContext(ctx context.Context) APIRateLimitSpecApiSelectorOutput {
	return o
}

func (o APIRateLimitSpecApiSelectorOutput) ToAPIRateLimitSpecApiSelectorPtrOutput() APIRateLimitSpecApiSelectorPtrOutput {
	return o.ToAPIRateLimitSpecApiSelectorPtrOutputWithContext(context.Background())
}

func (o APIRateLimitSpecApiSelectorOutput) ToAPIRateLimitSpecApiSelectorPtrOutputWithContext(ctx context.Context) APIRateLimitSpecApiSelectorPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v APIRateLimitSpecApiSelector) *APIRateLimitSpecApiSelector {
		return &v
	}).(APIRateLimitSpecApiSelectorPtrOutput)
}

func (o APIRateLimitSpecApiSelectorOutput) ToOutput(ctx context.Context) pulumix.Output[APIRateLimitSpecApiSelector] {
	return pulumix.Output[APIRateLimitSpecApiSelector]{
		OutputState: o.OutputState,
	}
}

// matchExpressions is a list of label selector requirements. The requirements are ANDed.
func (o APIRateLimitSpecApiSelectorOutput) MatchExpressions() APIRateLimitSpecApiSelectorMatchExpressionsArrayOutput {
	return o.ApplyT(func(v APIRateLimitSpecApiSelector) []APIRateLimitSpecApiSelectorMatchExpressions {
		return v.MatchExpressions
	}).(APIRateLimitSpecApiSelectorMatchExpressionsArrayOutput)
}

// matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
// map is equivalent to an element of matchExpressions, whose key field is "key", the
// operator is "In", and the values array contains only "value". The requirements are ANDed.
func (o APIRateLimitSpecApiSelectorOutput) MatchLabels() pulumi.StringMapOutput {
	return o.ApplyT(func(v APIRateLimitSpecApiSelector) map[string]string { return v.MatchLabels }).(pulumi.StringMapOutput)
}

type APIRateLimitSpecApiSelectorPtrOutput struct{ *pulumi.OutputState }

func (APIRateLimitSpecApiSelectorPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**APIRateLimitSpecApiSelector)(nil)).Elem()
}

func (o APIRateLimitSpecApiSelectorPtrOutput) ToAPIRateLimitSpecApiSelectorPtrOutput() APIRateLimitSpecApiSelectorPtrOutput {
	return o
}

func (o APIRateLimitSpecApiSelectorPtrOutput) ToAPIRateLimitSpecApiSelectorPtrOutputWithContext(ctx context.Context) APIRateLimitSpecApiSelectorPtrOutput {
	return o
}

func (o APIRateLimitSpecApiSelectorPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*APIRateLimitSpecApiSelector] {
	return pulumix.Output[*APIRateLimitSpecApiSelector]{
		OutputState: o.OutputState,
	}
}

func (o APIRateLimitSpecApiSelectorPtrOutput) Elem() APIRateLimitSpecApiSelectorOutput {
	return o.ApplyT(func(v *APIRateLimitSpecApiSelector) APIRateLimitSpecApiSelector {
		if v != nil {
			return *v
		}
		var ret APIRateLimitSpecApiSelector
		return ret
	}).(APIRateLimitSpecApiSelectorOutput)
}

// matchExpressions is a list of label selector requirements. The requirements are ANDed.
func (o APIRateLimitSpecApiSelectorPtrOutput) MatchExpressions() APIRateLimitSpecApiSelectorMatchExpressionsArrayOutput {
	return o.ApplyT(func(v *APIRateLimitSpecApiSelector) []APIRateLimitSpecApiSelectorMatchExpressions {
		if v == nil {
			return nil
		}
		return v.MatchExpressions
	}).(APIRateLimitSpecApiSelectorMatchExpressionsArrayOutput)
}

// matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
// map is equivalent to an element of matchExpressions, whose key field is "key", the
// operator is "In", and the values array contains only "value". The requirements are ANDed.
func (o APIRateLimitSpecApiSelectorPtrOutput) MatchLabels() pulumi.StringMapOutput {
	return o.ApplyT(func(v *APIRateLimitSpecApiSelector) map[string]string {
		if v == nil {
			return nil
		}
		return v.MatchLabels
	}).(pulumi.StringMapOutput)
}

// A label selector requirement is a selector that contains values, a key, and an operator that
// relates the key and values.
type APIRateLimitSpecApiSelectorMatchExpressions struct {
	// key is the label key that the selector applies to.
	Key string `pulumi:"key"`
	// operator represents a key's relationship to a set of values.
	// Valid operators are In, NotIn, Exists and DoesNotExist.
	Operator string `pulumi:"operator"`
	// values is an array of string values. If the operator is In or NotIn,
	// the values array must be non-empty. If the operator is Exists or DoesNotExist,
	// the values array must be empty. This array is replaced during a strategic
	// merge patch.
	Values []string `pulumi:"values"`
}

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

	ToAPIRateLimitSpecApiSelectorMatchExpressionsOutput() APIRateLimitSpecApiSelectorMatchExpressionsOutput
	ToAPIRateLimitSpecApiSelectorMatchExpressionsOutputWithContext(context.Context) APIRateLimitSpecApiSelectorMatchExpressionsOutput
}

// A label selector requirement is a selector that contains values, a key, and an operator that
// relates the key and values.
type APIRateLimitSpecApiSelectorMatchExpressionsArgs struct {
	// key is the label key that the selector applies to.
	Key pulumi.StringInput `pulumi:"key"`
	// operator represents a key's relationship to a set of values.
	// Valid operators are In, NotIn, Exists and DoesNotExist.
	Operator pulumi.StringInput `pulumi:"operator"`
	// values is an array of string values. If the operator is In or NotIn,
	// the values array must be non-empty. If the operator is Exists or DoesNotExist,
	// the values array must be empty. This array is replaced during a strategic
	// merge patch.
	Values pulumi.StringArrayInput `pulumi:"values"`
}

func (APIRateLimitSpecApiSelectorMatchExpressionsArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APIRateLimitSpecApiSelectorMatchExpressions)(nil)).Elem()
}

func (i APIRateLimitSpecApiSelectorMatchExpressionsArgs) ToAPIRateLimitSpecApiSelectorMatchExpressionsOutput() APIRateLimitSpecApiSelectorMatchExpressionsOutput {
	return i.ToAPIRateLimitSpecApiSelectorMatchExpressionsOutputWithContext(context.Background())
}

func (i APIRateLimitSpecApiSelectorMatchExpressionsArgs) ToAPIRateLimitSpecApiSelectorMatchExpressionsOutputWithContext(ctx context.Context) APIRateLimitSpecApiSelectorMatchExpressionsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIRateLimitSpecApiSelectorMatchExpressionsOutput)
}

func (i APIRateLimitSpecApiSelectorMatchExpressionsArgs) ToOutput(ctx context.Context) pulumix.Output[APIRateLimitSpecApiSelectorMatchExpressions] {
	return pulumix.Output[APIRateLimitSpecApiSelectorMatchExpressions]{
		OutputState: i.ToAPIRateLimitSpecApiSelectorMatchExpressionsOutputWithContext(ctx).OutputState,
	}
}

// APIRateLimitSpecApiSelectorMatchExpressionsArrayInput is an input type that accepts APIRateLimitSpecApiSelectorMatchExpressionsArray and APIRateLimitSpecApiSelectorMatchExpressionsArrayOutput values.
// You can construct a concrete instance of `APIRateLimitSpecApiSelectorMatchExpressionsArrayInput` via:
//
//	APIRateLimitSpecApiSelectorMatchExpressionsArray{ APIRateLimitSpecApiSelectorMatchExpressionsArgs{...} }
type APIRateLimitSpecApiSelectorMatchExpressionsArrayInput interface {
	pulumi.Input

	ToAPIRateLimitSpecApiSelectorMatchExpressionsArrayOutput() APIRateLimitSpecApiSelectorMatchExpressionsArrayOutput
	ToAPIRateLimitSpecApiSelectorMatchExpressionsArrayOutputWithContext(context.Context) APIRateLimitSpecApiSelectorMatchExpressionsArrayOutput
}

type APIRateLimitSpecApiSelectorMatchExpressionsArray []APIRateLimitSpecApiSelectorMatchExpressionsInput

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

func (i APIRateLimitSpecApiSelectorMatchExpressionsArray) ToAPIRateLimitSpecApiSelectorMatchExpressionsArrayOutput() APIRateLimitSpecApiSelectorMatchExpressionsArrayOutput {
	return i.ToAPIRateLimitSpecApiSelectorMatchExpressionsArrayOutputWithContext(context.Background())
}

func (i APIRateLimitSpecApiSelectorMatchExpressionsArray) ToAPIRateLimitSpecApiSelectorMatchExpressionsArrayOutputWithContext(ctx context.Context) APIRateLimitSpecApiSelectorMatchExpressionsArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIRateLimitSpecApiSelectorMatchExpressionsArrayOutput)
}

func (i APIRateLimitSpecApiSelectorMatchExpressionsArray) ToOutput(ctx context.Context) pulumix.Output[[]APIRateLimitSpecApiSelectorMatchExpressions] {
	return pulumix.Output[[]APIRateLimitSpecApiSelectorMatchExpressions]{
		OutputState: i.ToAPIRateLimitSpecApiSelectorMatchExpressionsArrayOutputWithContext(ctx).OutputState,
	}
}

// A label selector requirement is a selector that contains values, a key, and an operator that
// relates the key and values.
type APIRateLimitSpecApiSelectorMatchExpressionsOutput struct{ *pulumi.OutputState }

func (APIRateLimitSpecApiSelectorMatchExpressionsOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APIRateLimitSpecApiSelectorMatchExpressions)(nil)).Elem()
}

func (o APIRateLimitSpecApiSelectorMatchExpressionsOutput) ToAPIRateLimitSpecApiSelectorMatchExpressionsOutput() APIRateLimitSpecApiSelectorMatchExpressionsOutput {
	return o
}

func (o APIRateLimitSpecApiSelectorMatchExpressionsOutput) ToAPIRateLimitSpecApiSelectorMatchExpressionsOutputWithContext(ctx context.Context) APIRateLimitSpecApiSelectorMatchExpressionsOutput {
	return o
}

func (o APIRateLimitSpecApiSelectorMatchExpressionsOutput) ToOutput(ctx context.Context) pulumix.Output[APIRateLimitSpecApiSelectorMatchExpressions] {
	return pulumix.Output[APIRateLimitSpecApiSelectorMatchExpressions]{
		OutputState: o.OutputState,
	}
}

// key is the label key that the selector applies to.
func (o APIRateLimitSpecApiSelectorMatchExpressionsOutput) Key() pulumi.StringOutput {
	return o.ApplyT(func(v APIRateLimitSpecApiSelectorMatchExpressions) string { return v.Key }).(pulumi.StringOutput)
}

// operator represents a key's relationship to a set of values.
// Valid operators are In, NotIn, Exists and DoesNotExist.
func (o APIRateLimitSpecApiSelectorMatchExpressionsOutput) Operator() pulumi.StringOutput {
	return o.ApplyT(func(v APIRateLimitSpecApiSelectorMatchExpressions) string { return v.Operator }).(pulumi.StringOutput)
}

// values is an array of string values. If the operator is In or NotIn,
// the values array must be non-empty. If the operator is Exists or DoesNotExist,
// the values array must be empty. This array is replaced during a strategic
// merge patch.
func (o APIRateLimitSpecApiSelectorMatchExpressionsOutput) Values() pulumi.StringArrayOutput {
	return o.ApplyT(func(v APIRateLimitSpecApiSelectorMatchExpressions) []string { return v.Values }).(pulumi.StringArrayOutput)
}

type APIRateLimitSpecApiSelectorMatchExpressionsArrayOutput struct{ *pulumi.OutputState }

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

func (o APIRateLimitSpecApiSelectorMatchExpressionsArrayOutput) ToAPIRateLimitSpecApiSelectorMatchExpressionsArrayOutput() APIRateLimitSpecApiSelectorMatchExpressionsArrayOutput {
	return o
}

func (o APIRateLimitSpecApiSelectorMatchExpressionsArrayOutput) ToAPIRateLimitSpecApiSelectorMatchExpressionsArrayOutputWithContext(ctx context.Context) APIRateLimitSpecApiSelectorMatchExpressionsArrayOutput {
	return o
}

func (o APIRateLimitSpecApiSelectorMatchExpressionsArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]APIRateLimitSpecApiSelectorMatchExpressions] {
	return pulumix.Output[[]APIRateLimitSpecApiSelectorMatchExpressions]{
		OutputState: o.OutputState,
	}
}

func (o APIRateLimitSpecApiSelectorMatchExpressionsArrayOutput) Index(i pulumi.IntInput) APIRateLimitSpecApiSelectorMatchExpressionsOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) APIRateLimitSpecApiSelectorMatchExpressions {
		return vs[0].([]APIRateLimitSpecApiSelectorMatchExpressions)[vs[1].(int)]
	}).(APIRateLimitSpecApiSelectorMatchExpressionsOutput)
}

// matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels
// map is equivalent to an element of matchExpressions, whose key field is "key", the
// operator is "In", and the values array contains only "value". The requirements are ANDed.
type APIRateLimitSpecApiSelectorMatchLabels struct {
}

// APIReference references an API.
type APIRateLimitSpecApis struct {
	// Name of the API.
	Name string `pulumi:"name"`
}

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

	ToAPIRateLimitSpecApisOutput() APIRateLimitSpecApisOutput
	ToAPIRateLimitSpecApisOutputWithContext(context.Context) APIRateLimitSpecApisOutput
}

// APIReference references an API.
type APIRateLimitSpecApisArgs struct {
	// Name of the API.
	Name pulumi.StringInput `pulumi:"name"`
}

func (APIRateLimitSpecApisArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APIRateLimitSpecApis)(nil)).Elem()
}

func (i APIRateLimitSpecApisArgs) ToAPIRateLimitSpecApisOutput() APIRateLimitSpecApisOutput {
	return i.ToAPIRateLimitSpecApisOutputWithContext(context.Background())
}

func (i APIRateLimitSpecApisArgs) ToAPIRateLimitSpecApisOutputWithContext(ctx context.Context) APIRateLimitSpecApisOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIRateLimitSpecApisOutput)
}

func (i APIRateLimitSpecApisArgs) ToOutput(ctx context.Context) pulumix.Output[APIRateLimitSpecApis] {
	return pulumix.Output[APIRateLimitSpecApis]{
		OutputState: i.ToAPIRateLimitSpecApisOutputWithContext(ctx).OutputState,
	}
}

// APIRateLimitSpecApisArrayInput is an input type that accepts APIRateLimitSpecApisArray and APIRateLimitSpecApisArrayOutput values.
// You can construct a concrete instance of `APIRateLimitSpecApisArrayInput` via:
//
//	APIRateLimitSpecApisArray{ APIRateLimitSpecApisArgs{...} }
type APIRateLimitSpecApisArrayInput interface {
	pulumi.Input

	ToAPIRateLimitSpecApisArrayOutput() APIRateLimitSpecApisArrayOutput
	ToAPIRateLimitSpecApisArrayOutputWithContext(context.Context) APIRateLimitSpecApisArrayOutput
}

type APIRateLimitSpecApisArray []APIRateLimitSpecApisInput

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

func (i APIRateLimitSpecApisArray) ToAPIRateLimitSpecApisArrayOutput() APIRateLimitSpecApisArrayOutput {
	return i.ToAPIRateLimitSpecApisArrayOutputWithContext(context.Background())
}

func (i APIRateLimitSpecApisArray) ToAPIRateLimitSpecApisArrayOutputWithContext(ctx context.Context) APIRateLimitSpecApisArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIRateLimitSpecApisArrayOutput)
}

func (i APIRateLimitSpecApisArray) ToOutput(ctx context.Context) pulumix.Output[[]APIRateLimitSpecApis] {
	return pulumix.Output[[]APIRateLimitSpecApis]{
		OutputState: i.ToAPIRateLimitSpecApisArrayOutputWithContext(ctx).OutputState,
	}
}

// APIReference references an API.
type APIRateLimitSpecApisOutput struct{ *pulumi.OutputState }

func (APIRateLimitSpecApisOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APIRateLimitSpecApis)(nil)).Elem()
}

func (o APIRateLimitSpecApisOutput) ToAPIRateLimitSpecApisOutput() APIRateLimitSpecApisOutput {
	return o
}

func (o APIRateLimitSpecApisOutput) ToAPIRateLimitSpecApisOutputWithContext(ctx context.Context) APIRateLimitSpecApisOutput {
	return o
}

func (o APIRateLimitSpecApisOutput) ToOutput(ctx context.Context) pulumix.Output[APIRateLimitSpecApis] {
	return pulumix.Output[APIRateLimitSpecApis]{
		OutputState: o.OutputState,
	}
}

// Name of the API.
func (o APIRateLimitSpecApisOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v APIRateLimitSpecApis) string { return v.Name }).(pulumi.StringOutput)
}

type APIRateLimitSpecApisArrayOutput struct{ *pulumi.OutputState }

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

func (o APIRateLimitSpecApisArrayOutput) ToAPIRateLimitSpecApisArrayOutput() APIRateLimitSpecApisArrayOutput {
	return o
}

func (o APIRateLimitSpecApisArrayOutput) ToAPIRateLimitSpecApisArrayOutputWithContext(ctx context.Context) APIRateLimitSpecApisArrayOutput {
	return o
}

func (o APIRateLimitSpecApisArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]APIRateLimitSpecApis] {
	return pulumix.Output[[]APIRateLimitSpecApis]{
		OutputState: o.OutputState,
	}
}

func (o APIRateLimitSpecApisArrayOutput) Index(i pulumi.IntInput) APIRateLimitSpecApisOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) APIRateLimitSpecApis {
		return vs[0].([]APIRateLimitSpecApis)[vs[1].(int)]
	}).(APIRateLimitSpecApisOutput)
}

// The current status of this APIRateLimit.
type APIRateLimitStatus struct {
	// Hash is a hash representing the APIRateLimit.
	Hash     *string `pulumi:"hash"`
	SyncedAt *string `pulumi:"syncedAt"`
	Version  *string `pulumi:"version"`
}

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

	ToAPIRateLimitStatusOutput() APIRateLimitStatusOutput
	ToAPIRateLimitStatusOutputWithContext(context.Context) APIRateLimitStatusOutput
}

// The current status of this APIRateLimit.
type APIRateLimitStatusArgs struct {
	// Hash is a hash representing the APIRateLimit.
	Hash     pulumi.StringPtrInput `pulumi:"hash"`
	SyncedAt pulumi.StringPtrInput `pulumi:"syncedAt"`
	Version  pulumi.StringPtrInput `pulumi:"version"`
}

func (APIRateLimitStatusArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APIRateLimitStatus)(nil)).Elem()
}

func (i APIRateLimitStatusArgs) ToAPIRateLimitStatusOutput() APIRateLimitStatusOutput {
	return i.ToAPIRateLimitStatusOutputWithContext(context.Background())
}

func (i APIRateLimitStatusArgs) ToAPIRateLimitStatusOutputWithContext(ctx context.Context) APIRateLimitStatusOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIRateLimitStatusOutput)
}

func (i APIRateLimitStatusArgs) ToOutput(ctx context.Context) pulumix.Output[APIRateLimitStatus] {
	return pulumix.Output[APIRateLimitStatus]{
		OutputState: i.ToAPIRateLimitStatusOutputWithContext(ctx).OutputState,
	}
}

func (i APIRateLimitStatusArgs) ToAPIRateLimitStatusPtrOutput() APIRateLimitStatusPtrOutput {
	return i.ToAPIRateLimitStatusPtrOutputWithContext(context.Background())
}

func (i APIRateLimitStatusArgs) ToAPIRateLimitStatusPtrOutputWithContext(ctx context.Context) APIRateLimitStatusPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIRateLimitStatusOutput).ToAPIRateLimitStatusPtrOutputWithContext(ctx)
}

// APIRateLimitStatusPtrInput is an input type that accepts APIRateLimitStatusArgs, APIRateLimitStatusPtr and APIRateLimitStatusPtrOutput values.
// You can construct a concrete instance of `APIRateLimitStatusPtrInput` via:
//
//	        APIRateLimitStatusArgs{...}
//
//	or:
//
//	        nil
type APIRateLimitStatusPtrInput interface {
	pulumi.Input

	ToAPIRateLimitStatusPtrOutput() APIRateLimitStatusPtrOutput
	ToAPIRateLimitStatusPtrOutputWithContext(context.Context) APIRateLimitStatusPtrOutput
}

type apirateLimitStatusPtrType APIRateLimitStatusArgs

func APIRateLimitStatusPtr(v *APIRateLimitStatusArgs) APIRateLimitStatusPtrInput {
	return (*apirateLimitStatusPtrType)(v)
}

func (*apirateLimitStatusPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**APIRateLimitStatus)(nil)).Elem()
}

func (i *apirateLimitStatusPtrType) ToAPIRateLimitStatusPtrOutput() APIRateLimitStatusPtrOutput {
	return i.ToAPIRateLimitStatusPtrOutputWithContext(context.Background())
}

func (i *apirateLimitStatusPtrType) ToAPIRateLimitStatusPtrOutputWithContext(ctx context.Context) APIRateLimitStatusPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIRateLimitStatusPtrOutput)
}

func (i *apirateLimitStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*APIRateLimitStatus] {
	return pulumix.Output[*APIRateLimitStatus]{
		OutputState: i.ToAPIRateLimitStatusPtrOutputWithContext(ctx).OutputState,
	}
}

// The current status of this APIRateLimit.
type APIRateLimitStatusOutput struct{ *pulumi.OutputState }

func (APIRateLimitStatusOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APIRateLimitStatus)(nil)).Elem()
}

func (o APIRateLimitStatusOutput) ToAPIRateLimitStatusOutput() APIRateLimitStatusOutput {
	return o
}

func (o APIRateLimitStatusOutput) ToAPIRateLimitStatusOutputWithContext(ctx context.Context) APIRateLimitStatusOutput {
	return o
}

func (o APIRateLimitStatusOutput) ToAPIRateLimitStatusPtrOutput() APIRateLimitStatusPtrOutput {
	return o.ToAPIRateLimitStatusPtrOutputWithContext(context.Background())
}

func (o APIRateLimitStatusOutput) ToAPIRateLimitStatusPtrOutputWithContext(ctx context.Context) APIRateLimitStatusPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v APIRateLimitStatus) *APIRateLimitStatus {
		return &v
	}).(APIRateLimitStatusPtrOutput)
}

func (o APIRateLimitStatusOutput) ToOutput(ctx context.Context) pulumix.Output[APIRateLimitStatus] {
	return pulumix.Output[APIRateLimitStatus]{
		OutputState: o.OutputState,
	}
}

// Hash is a hash representing the APIRateLimit.
func (o APIRateLimitStatusOutput) Hash() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIRateLimitStatus) *string { return v.Hash }).(pulumi.StringPtrOutput)
}

func (o APIRateLimitStatusOutput) SyncedAt() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIRateLimitStatus) *string { return v.SyncedAt }).(pulumi.StringPtrOutput)
}

func (o APIRateLimitStatusOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIRateLimitStatus) *string { return v.Version }).(pulumi.StringPtrOutput)
}

type APIRateLimitStatusPtrOutput struct{ *pulumi.OutputState }

func (APIRateLimitStatusPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**APIRateLimitStatus)(nil)).Elem()
}

func (o APIRateLimitStatusPtrOutput) ToAPIRateLimitStatusPtrOutput() APIRateLimitStatusPtrOutput {
	return o
}

func (o APIRateLimitStatusPtrOutput) ToAPIRateLimitStatusPtrOutputWithContext(ctx context.Context) APIRateLimitStatusPtrOutput {
	return o
}

func (o APIRateLimitStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*APIRateLimitStatus] {
	return pulumix.Output[*APIRateLimitStatus]{
		OutputState: o.OutputState,
	}
}

func (o APIRateLimitStatusPtrOutput) Elem() APIRateLimitStatusOutput {
	return o.ApplyT(func(v *APIRateLimitStatus) APIRateLimitStatus {
		if v != nil {
			return *v
		}
		var ret APIRateLimitStatus
		return ret
	}).(APIRateLimitStatusOutput)
}

// Hash is a hash representing the APIRateLimit.
func (o APIRateLimitStatusPtrOutput) Hash() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIRateLimitStatus) *string {
		if v == nil {
			return nil
		}
		return v.Hash
	}).(pulumi.StringPtrOutput)
}

func (o APIRateLimitStatusPtrOutput) SyncedAt() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIRateLimitStatus) *string {
		if v == nil {
			return nil
		}
		return v.SyncedAt
	}).(pulumi.StringPtrOutput)
}

func (o APIRateLimitStatusPtrOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIRateLimitStatus) *string {
		if v == nil {
			return nil
		}
		return v.Version
	}).(pulumi.StringPtrOutput)
}

// APISpec describes the API.
type APISpec struct {
	// OpenAPISpec defines the API contract as an OpenAPI specification.
	OpenApiSpec *APISpecOpenApiSpec `pulumi:"openApiSpec"`
	// Versions are the different APIVersions available.
	Versions []APISpecVersions `pulumi:"versions"`
}

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

	ToAPISpecOutput() APISpecOutput
	ToAPISpecOutputWithContext(context.Context) APISpecOutput
}

// APISpec describes the API.
type APISpecArgs struct {
	// OpenAPISpec defines the API contract as an OpenAPI specification.
	OpenApiSpec APISpecOpenApiSpecPtrInput `pulumi:"openApiSpec"`
	// Versions are the different APIVersions available.
	Versions APISpecVersionsArrayInput `pulumi:"versions"`
}

func (APISpecArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APISpec)(nil)).Elem()
}

func (i APISpecArgs) ToAPISpecOutput() APISpecOutput {
	return i.ToAPISpecOutputWithContext(context.Background())
}

func (i APISpecArgs) ToAPISpecOutputWithContext(ctx context.Context) APISpecOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APISpecOutput)
}

func (i APISpecArgs) ToOutput(ctx context.Context) pulumix.Output[APISpec] {
	return pulumix.Output[APISpec]{
		OutputState: i.ToAPISpecOutputWithContext(ctx).OutputState,
	}
}

func (i APISpecArgs) ToAPISpecPtrOutput() APISpecPtrOutput {
	return i.ToAPISpecPtrOutputWithContext(context.Background())
}

func (i APISpecArgs) ToAPISpecPtrOutputWithContext(ctx context.Context) APISpecPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APISpecOutput).ToAPISpecPtrOutputWithContext(ctx)
}

// APISpecPtrInput is an input type that accepts APISpecArgs, APISpecPtr and APISpecPtrOutput values.
// You can construct a concrete instance of `APISpecPtrInput` via:
//
//	        APISpecArgs{...}
//
//	or:
//
//	        nil
type APISpecPtrInput interface {
	pulumi.Input

	ToAPISpecPtrOutput() APISpecPtrOutput
	ToAPISpecPtrOutputWithContext(context.Context) APISpecPtrOutput
}

type apispecPtrType APISpecArgs

func APISpecPtr(v *APISpecArgs) APISpecPtrInput {
	return (*apispecPtrType)(v)
}

func (*apispecPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**APISpec)(nil)).Elem()
}

func (i *apispecPtrType) ToAPISpecPtrOutput() APISpecPtrOutput {
	return i.ToAPISpecPtrOutputWithContext(context.Background())
}

func (i *apispecPtrType) ToAPISpecPtrOutputWithContext(ctx context.Context) APISpecPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APISpecPtrOutput)
}

func (i *apispecPtrType) ToOutput(ctx context.Context) pulumix.Output[*APISpec] {
	return pulumix.Output[*APISpec]{
		OutputState: i.ToAPISpecPtrOutputWithContext(ctx).OutputState,
	}
}

// APISpec describes the API.
type APISpecOutput struct{ *pulumi.OutputState }

func (APISpecOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APISpec)(nil)).Elem()
}

func (o APISpecOutput) ToAPISpecOutput() APISpecOutput {
	return o
}

func (o APISpecOutput) ToAPISpecOutputWithContext(ctx context.Context) APISpecOutput {
	return o
}

func (o APISpecOutput) ToAPISpecPtrOutput() APISpecPtrOutput {
	return o.ToAPISpecPtrOutputWithContext(context.Background())
}

func (o APISpecOutput) ToAPISpecPtrOutputWithContext(ctx context.Context) APISpecPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v APISpec) *APISpec {
		return &v
	}).(APISpecPtrOutput)
}

func (o APISpecOutput) ToOutput(ctx context.Context) pulumix.Output[APISpec] {
	return pulumix.Output[APISpec]{
		OutputState: o.OutputState,
	}
}

// OpenAPISpec defines the API contract as an OpenAPI specification.
func (o APISpecOutput) OpenApiSpec() APISpecOpenApiSpecPtrOutput {
	return o.ApplyT(func(v APISpec) *APISpecOpenApiSpec { return v.OpenApiSpec }).(APISpecOpenApiSpecPtrOutput)
}

// Versions are the different APIVersions available.
func (o APISpecOutput) Versions() APISpecVersionsArrayOutput {
	return o.ApplyT(func(v APISpec) []APISpecVersions { return v.Versions }).(APISpecVersionsArrayOutput)
}

type APISpecPtrOutput struct{ *pulumi.OutputState }

func (APISpecPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**APISpec)(nil)).Elem()
}

func (o APISpecPtrOutput) ToAPISpecPtrOutput() APISpecPtrOutput {
	return o
}

func (o APISpecPtrOutput) ToAPISpecPtrOutputWithContext(ctx context.Context) APISpecPtrOutput {
	return o
}

func (o APISpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*APISpec] {
	return pulumix.Output[*APISpec]{
		OutputState: o.OutputState,
	}
}

func (o APISpecPtrOutput) Elem() APISpecOutput {
	return o.ApplyT(func(v *APISpec) APISpec {
		if v != nil {
			return *v
		}
		var ret APISpec
		return ret
	}).(APISpecOutput)
}

// OpenAPISpec defines the API contract as an OpenAPI specification.
func (o APISpecPtrOutput) OpenApiSpec() APISpecOpenApiSpecPtrOutput {
	return o.ApplyT(func(v *APISpec) *APISpecOpenApiSpec {
		if v == nil {
			return nil
		}
		return v.OpenApiSpec
	}).(APISpecOpenApiSpecPtrOutput)
}

// Versions are the different APIVersions available.
func (o APISpecPtrOutput) Versions() APISpecVersionsArrayOutput {
	return o.ApplyT(func(v *APISpec) []APISpecVersions {
		if v == nil {
			return nil
		}
		return v.Versions
	}).(APISpecVersionsArrayOutput)
}

// OpenAPISpec defines the API contract as an OpenAPI specification.
type APISpecOpenApiSpec struct {
	// OperationSets defines the sets of operations to be referenced for granular filtering in APIAccesses.
	OperationSets []APISpecOpenApiSpecOperationSets `pulumi:"operationSets"`
	// Override holds data used to override OpenAPI specification.
	Override *APISpecOpenApiSpecOverride `pulumi:"override"`
	// Path specifies the endpoint path within the Kubernetes Service where the OpenAPI specification can be obtained.
	// The Service queried is determined by the associated Ingress, IngressRoute, or HTTPRoute resource to which the API is attached.
	// It's important to note that this option is incompatible if the Ingress or IngressRoute specifies multiple backend services.
	// The Path must be accessible via a GET request method and should serve a YAML or JSON document containing the OpenAPI specification.
	Path *string `pulumi:"path"`
	// URL is a Traefik Hub agent accessible URL for obtaining the OpenAPI specification.
	// The URL must be accessible via a GET request method and should serve a YAML or JSON document containing the OpenAPI specification.
	Url *string `pulumi:"url"`
}

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

	ToAPISpecOpenApiSpecOutput() APISpecOpenApiSpecOutput
	ToAPISpecOpenApiSpecOutputWithContext(context.Context) APISpecOpenApiSpecOutput
}

// OpenAPISpec defines the API contract as an OpenAPI specification.
type APISpecOpenApiSpecArgs struct {
	// OperationSets defines the sets of operations to be referenced for granular filtering in APIAccesses.
	OperationSets APISpecOpenApiSpecOperationSetsArrayInput `pulumi:"operationSets"`
	// Override holds data used to override OpenAPI specification.
	Override APISpecOpenApiSpecOverridePtrInput `pulumi:"override"`
	// Path specifies the endpoint path within the Kubernetes Service where the OpenAPI specification can be obtained.
	// The Service queried is determined by the associated Ingress, IngressRoute, or HTTPRoute resource to which the API is attached.
	// It's important to note that this option is incompatible if the Ingress or IngressRoute specifies multiple backend services.
	// The Path must be accessible via a GET request method and should serve a YAML or JSON document containing the OpenAPI specification.
	Path pulumi.StringPtrInput `pulumi:"path"`
	// URL is a Traefik Hub agent accessible URL for obtaining the OpenAPI specification.
	// The URL must be accessible via a GET request method and should serve a YAML or JSON document containing the OpenAPI specification.
	Url pulumi.StringPtrInput `pulumi:"url"`
}

func (APISpecOpenApiSpecArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APISpecOpenApiSpec)(nil)).Elem()
}

func (i APISpecOpenApiSpecArgs) ToAPISpecOpenApiSpecOutput() APISpecOpenApiSpecOutput {
	return i.ToAPISpecOpenApiSpecOutputWithContext(context.Background())
}

func (i APISpecOpenApiSpecArgs) ToAPISpecOpenApiSpecOutputWithContext(ctx context.Context) APISpecOpenApiSpecOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APISpecOpenApiSpecOutput)
}

func (i APISpecOpenApiSpecArgs) ToOutput(ctx context.Context) pulumix.Output[APISpecOpenApiSpec] {
	return pulumix.Output[APISpecOpenApiSpec]{
		OutputState: i.ToAPISpecOpenApiSpecOutputWithContext(ctx).OutputState,
	}
}

func (i APISpecOpenApiSpecArgs) ToAPISpecOpenApiSpecPtrOutput() APISpecOpenApiSpecPtrOutput {
	return i.ToAPISpecOpenApiSpecPtrOutputWithContext(context.Background())
}

func (i APISpecOpenApiSpecArgs) ToAPISpecOpenApiSpecPtrOutputWithContext(ctx context.Context) APISpecOpenApiSpecPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APISpecOpenApiSpecOutput).ToAPISpecOpenApiSpecPtrOutputWithContext(ctx)
}

// APISpecOpenApiSpecPtrInput is an input type that accepts APISpecOpenApiSpecArgs, APISpecOpenApiSpecPtr and APISpecOpenApiSpecPtrOutput values.
// You can construct a concrete instance of `APISpecOpenApiSpecPtrInput` via:
//
//	        APISpecOpenApiSpecArgs{...}
//
//	or:
//
//	        nil
type APISpecOpenApiSpecPtrInput interface {
	pulumi.Input

	ToAPISpecOpenApiSpecPtrOutput() APISpecOpenApiSpecPtrOutput
	ToAPISpecOpenApiSpecPtrOutputWithContext(context.Context) APISpecOpenApiSpecPtrOutput
}

type apispecOpenApiSpecPtrType APISpecOpenApiSpecArgs

func APISpecOpenApiSpecPtr(v *APISpecOpenApiSpecArgs) APISpecOpenApiSpecPtrInput {
	return (*apispecOpenApiSpecPtrType)(v)
}

func (*apispecOpenApiSpecPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**APISpecOpenApiSpec)(nil)).Elem()
}

func (i *apispecOpenApiSpecPtrType) ToAPISpecOpenApiSpecPtrOutput() APISpecOpenApiSpecPtrOutput {
	return i.ToAPISpecOpenApiSpecPtrOutputWithContext(context.Background())
}

func (i *apispecOpenApiSpecPtrType) ToAPISpecOpenApiSpecPtrOutputWithContext(ctx context.Context) APISpecOpenApiSpecPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APISpecOpenApiSpecPtrOutput)
}

func (i *apispecOpenApiSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*APISpecOpenApiSpec] {
	return pulumix.Output[*APISpecOpenApiSpec]{
		OutputState: i.ToAPISpecOpenApiSpecPtrOutputWithContext(ctx).OutputState,
	}
}

// OpenAPISpec defines the API contract as an OpenAPI specification.
type APISpecOpenApiSpecOutput struct{ *pulumi.OutputState }

func (APISpecOpenApiSpecOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APISpecOpenApiSpec)(nil)).Elem()
}

func (o APISpecOpenApiSpecOutput) ToAPISpecOpenApiSpecOutput() APISpecOpenApiSpecOutput {
	return o
}

func (o APISpecOpenApiSpecOutput) ToAPISpecOpenApiSpecOutputWithContext(ctx context.Context) APISpecOpenApiSpecOutput {
	return o
}

func (o APISpecOpenApiSpecOutput) ToAPISpecOpenApiSpecPtrOutput() APISpecOpenApiSpecPtrOutput {
	return o.ToAPISpecOpenApiSpecPtrOutputWithContext(context.Background())
}

func (o APISpecOpenApiSpecOutput) ToAPISpecOpenApiSpecPtrOutputWithContext(ctx context.Context) APISpecOpenApiSpecPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v APISpecOpenApiSpec) *APISpecOpenApiSpec {
		return &v
	}).(APISpecOpenApiSpecPtrOutput)
}

func (o APISpecOpenApiSpecOutput) ToOutput(ctx context.Context) pulumix.Output[APISpecOpenApiSpec] {
	return pulumix.Output[APISpecOpenApiSpec]{
		OutputState: o.OutputState,
	}
}

// OperationSets defines the sets of operations to be referenced for granular filtering in APIAccesses.
func (o APISpecOpenApiSpecOutput) OperationSets() APISpecOpenApiSpecOperationSetsArrayOutput {
	return o.ApplyT(func(v APISpecOpenApiSpec) []APISpecOpenApiSpecOperationSets { return v.OperationSets }).(APISpecOpenApiSpecOperationSetsArrayOutput)
}

// Override holds data used to override OpenAPI specification.
func (o APISpecOpenApiSpecOutput) Override() APISpecOpenApiSpecOverridePtrOutput {
	return o.ApplyT(func(v APISpecOpenApiSpec) *APISpecOpenApiSpecOverride { return v.Override }).(APISpecOpenApiSpecOverridePtrOutput)
}

// Path specifies the endpoint path within the Kubernetes Service where the OpenAPI specification can be obtained.
// The Service queried is determined by the associated Ingress, IngressRoute, or HTTPRoute resource to which the API is attached.
// It's important to note that this option is incompatible if the Ingress or IngressRoute specifies multiple backend services.
// The Path must be accessible via a GET request method and should serve a YAML or JSON document containing the OpenAPI specification.
func (o APISpecOpenApiSpecOutput) Path() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APISpecOpenApiSpec) *string { return v.Path }).(pulumi.StringPtrOutput)
}

// URL is a Traefik Hub agent accessible URL for obtaining the OpenAPI specification.
// The URL must be accessible via a GET request method and should serve a YAML or JSON document containing the OpenAPI specification.
func (o APISpecOpenApiSpecOutput) Url() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APISpecOpenApiSpec) *string { return v.Url }).(pulumi.StringPtrOutput)
}

type APISpecOpenApiSpecPtrOutput struct{ *pulumi.OutputState }

func (APISpecOpenApiSpecPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**APISpecOpenApiSpec)(nil)).Elem()
}

func (o APISpecOpenApiSpecPtrOutput) ToAPISpecOpenApiSpecPtrOutput() APISpecOpenApiSpecPtrOutput {
	return o
}

func (o APISpecOpenApiSpecPtrOutput) ToAPISpecOpenApiSpecPtrOutputWithContext(ctx context.Context) APISpecOpenApiSpecPtrOutput {
	return o
}

func (o APISpecOpenApiSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*APISpecOpenApiSpec] {
	return pulumix.Output[*APISpecOpenApiSpec]{
		OutputState: o.OutputState,
	}
}

func (o APISpecOpenApiSpecPtrOutput) Elem() APISpecOpenApiSpecOutput {
	return o.ApplyT(func(v *APISpecOpenApiSpec) APISpecOpenApiSpec {
		if v != nil {
			return *v
		}
		var ret APISpecOpenApiSpec
		return ret
	}).(APISpecOpenApiSpecOutput)
}

// OperationSets defines the sets of operations to be referenced for granular filtering in APIAccesses.
func (o APISpecOpenApiSpecPtrOutput) OperationSets() APISpecOpenApiSpecOperationSetsArrayOutput {
	return o.ApplyT(func(v *APISpecOpenApiSpec) []APISpecOpenApiSpecOperationSets {
		if v == nil {
			return nil
		}
		return v.OperationSets
	}).(APISpecOpenApiSpecOperationSetsArrayOutput)
}

// Override holds data used to override OpenAPI specification.
func (o APISpecOpenApiSpecPtrOutput) Override() APISpecOpenApiSpecOverridePtrOutput {
	return o.ApplyT(func(v *APISpecOpenApiSpec) *APISpecOpenApiSpecOverride {
		if v == nil {
			return nil
		}
		return v.Override
	}).(APISpecOpenApiSpecOverridePtrOutput)
}

// Path specifies the endpoint path within the Kubernetes Service where the OpenAPI specification can be obtained.
// The Service queried is determined by the associated Ingress, IngressRoute, or HTTPRoute resource to which the API is attached.
// It's important to note that this option is incompatible if the Ingress or IngressRoute specifies multiple backend services.
// The Path must be accessible via a GET request method and should serve a YAML or JSON document containing the OpenAPI specification.
func (o APISpecOpenApiSpecPtrOutput) Path() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APISpecOpenApiSpec) *string {
		if v == nil {
			return nil
		}
		return v.Path
	}).(pulumi.StringPtrOutput)
}

// URL is a Traefik Hub agent accessible URL for obtaining the OpenAPI specification.
// The URL must be accessible via a GET request method and should serve a YAML or JSON document containing the OpenAPI specification.
func (o APISpecOpenApiSpecPtrOutput) Url() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APISpecOpenApiSpec) *string {
		if v == nil {
			return nil
		}
		return v.Url
	}).(pulumi.StringPtrOutput)
}

// OperationSet gives a name to a set of matching OpenAPI operations.
// This set of operations can then be referenced for granular filtering in APIAccesses.
type APISpecOpenApiSpecOperationSets struct {
	// Matchers defines a list of alternative rules for matching OpenAPI operations.
	Matchers []APISpecOpenApiSpecOperationSetsMatchers `pulumi:"matchers"`
	// Name is the name of the OperationSet to reference in APIAccesses.
	Name string `pulumi:"name"`
}

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

	ToAPISpecOpenApiSpecOperationSetsOutput() APISpecOpenApiSpecOperationSetsOutput
	ToAPISpecOpenApiSpecOperationSetsOutputWithContext(context.Context) APISpecOpenApiSpecOperationSetsOutput
}

// OperationSet gives a name to a set of matching OpenAPI operations.
// This set of operations can then be referenced for granular filtering in APIAccesses.
type APISpecOpenApiSpecOperationSetsArgs struct {
	// Matchers defines a list of alternative rules for matching OpenAPI operations.
	Matchers APISpecOpenApiSpecOperationSetsMatchersArrayInput `pulumi:"matchers"`
	// Name is the name of the OperationSet to reference in APIAccesses.
	Name pulumi.StringInput `pulumi:"name"`
}

func (APISpecOpenApiSpecOperationSetsArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APISpecOpenApiSpecOperationSets)(nil)).Elem()
}

func (i APISpecOpenApiSpecOperationSetsArgs) ToAPISpecOpenApiSpecOperationSetsOutput() APISpecOpenApiSpecOperationSetsOutput {
	return i.ToAPISpecOpenApiSpecOperationSetsOutputWithContext(context.Background())
}

func (i APISpecOpenApiSpecOperationSetsArgs) ToAPISpecOpenApiSpecOperationSetsOutputWithContext(ctx context.Context) APISpecOpenApiSpecOperationSetsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APISpecOpenApiSpecOperationSetsOutput)
}

func (i APISpecOpenApiSpecOperationSetsArgs) ToOutput(ctx context.Context) pulumix.Output[APISpecOpenApiSpecOperationSets] {
	return pulumix.Output[APISpecOpenApiSpecOperationSets]{
		OutputState: i.ToAPISpecOpenApiSpecOperationSetsOutputWithContext(ctx).OutputState,
	}
}

// APISpecOpenApiSpecOperationSetsArrayInput is an input type that accepts APISpecOpenApiSpecOperationSetsArray and APISpecOpenApiSpecOperationSetsArrayOutput values.
// You can construct a concrete instance of `APISpecOpenApiSpecOperationSetsArrayInput` via:
//
//	APISpecOpenApiSpecOperationSetsArray{ APISpecOpenApiSpecOperationSetsArgs{...} }
type APISpecOpenApiSpecOperationSetsArrayInput interface {
	pulumi.Input

	ToAPISpecOpenApiSpecOperationSetsArrayOutput() APISpecOpenApiSpecOperationSetsArrayOutput
	ToAPISpecOpenApiSpecOperationSetsArrayOutputWithContext(context.Context) APISpecOpenApiSpecOperationSetsArrayOutput
}

type APISpecOpenApiSpecOperationSetsArray []APISpecOpenApiSpecOperationSetsInput

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

func (i APISpecOpenApiSpecOperationSetsArray) ToAPISpecOpenApiSpecOperationSetsArrayOutput() APISpecOpenApiSpecOperationSetsArrayOutput {
	return i.ToAPISpecOpenApiSpecOperationSetsArrayOutputWithContext(context.Background())
}

func (i APISpecOpenApiSpecOperationSetsArray) ToAPISpecOpenApiSpecOperationSetsArrayOutputWithContext(ctx context.Context) APISpecOpenApiSpecOperationSetsArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APISpecOpenApiSpecOperationSetsArrayOutput)
}

func (i APISpecOpenApiSpecOperationSetsArray) ToOutput(ctx context.Context) pulumix.Output[[]APISpecOpenApiSpecOperationSets] {
	return pulumix.Output[[]APISpecOpenApiSpecOperationSets]{
		OutputState: i.ToAPISpecOpenApiSpecOperationSetsArrayOutputWithContext(ctx).OutputState,
	}
}

// OperationSet gives a name to a set of matching OpenAPI operations.
// This set of operations can then be referenced for granular filtering in APIAccesses.
type APISpecOpenApiSpecOperationSetsOutput struct{ *pulumi.OutputState }

func (APISpecOpenApiSpecOperationSetsOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APISpecOpenApiSpecOperationSets)(nil)).Elem()
}

func (o APISpecOpenApiSpecOperationSetsOutput) ToAPISpecOpenApiSpecOperationSetsOutput() APISpecOpenApiSpecOperationSetsOutput {
	return o
}

func (o APISpecOpenApiSpecOperationSetsOutput) ToAPISpecOpenApiSpecOperationSetsOutputWithContext(ctx context.Context) APISpecOpenApiSpecOperationSetsOutput {
	return o
}

func (o APISpecOpenApiSpecOperationSetsOutput) ToOutput(ctx context.Context) pulumix.Output[APISpecOpenApiSpecOperationSets] {
	return pulumix.Output[APISpecOpenApiSpecOperationSets]{
		OutputState: o.OutputState,
	}
}

// Matchers defines a list of alternative rules for matching OpenAPI operations.
func (o APISpecOpenApiSpecOperationSetsOutput) Matchers() APISpecOpenApiSpecOperationSetsMatchersArrayOutput {
	return o.ApplyT(func(v APISpecOpenApiSpecOperationSets) []APISpecOpenApiSpecOperationSetsMatchers { return v.Matchers }).(APISpecOpenApiSpecOperationSetsMatchersArrayOutput)
}

// Name is the name of the OperationSet to reference in APIAccesses.
func (o APISpecOpenApiSpecOperationSetsOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v APISpecOpenApiSpecOperationSets) string { return v.Name }).(pulumi.StringOutput)
}

type APISpecOpenApiSpecOperationSetsArrayOutput struct{ *pulumi.OutputState }

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

func (o APISpecOpenApiSpecOperationSetsArrayOutput) ToAPISpecOpenApiSpecOperationSetsArrayOutput() APISpecOpenApiSpecOperationSetsArrayOutput {
	return o
}

func (o APISpecOpenApiSpecOperationSetsArrayOutput) ToAPISpecOpenApiSpecOperationSetsArrayOutputWithContext(ctx context.Context) APISpecOpenApiSpecOperationSetsArrayOutput {
	return o
}

func (o APISpecOpenApiSpecOperationSetsArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]APISpecOpenApiSpecOperationSets] {
	return pulumix.Output[[]APISpecOpenApiSpecOperationSets]{
		OutputState: o.OutputState,
	}
}

func (o APISpecOpenApiSpecOperationSetsArrayOutput) Index(i pulumi.IntInput) APISpecOpenApiSpecOperationSetsOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) APISpecOpenApiSpecOperationSets {
		return vs[0].([]APISpecOpenApiSpecOperationSets)[vs[1].(int)]
	}).(APISpecOpenApiSpecOperationSetsOutput)
}

// OperationMatcher defines criteria for matching an OpenAPI operation.
type APISpecOpenApiSpecOperationSetsMatchers struct {
	// Methods specifies the HTTP methods to be included for selection.
	Methods []string `pulumi:"methods"`
	// Path specifies the exact path of the operations to select.
	Path *string `pulumi:"path"`
	// PathPrefix specifies the path prefix of the operations to select.
	PathPrefix *string `pulumi:"pathPrefix"`
	// PathRegex specifies a regular expression pattern for matching operations based on their paths.
	PathRegex *string `pulumi:"pathRegex"`
}

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

	ToAPISpecOpenApiSpecOperationSetsMatchersOutput() APISpecOpenApiSpecOperationSetsMatchersOutput
	ToAPISpecOpenApiSpecOperationSetsMatchersOutputWithContext(context.Context) APISpecOpenApiSpecOperationSetsMatchersOutput
}

// OperationMatcher defines criteria for matching an OpenAPI operation.
type APISpecOpenApiSpecOperationSetsMatchersArgs struct {
	// Methods specifies the HTTP methods to be included for selection.
	Methods pulumi.StringArrayInput `pulumi:"methods"`
	// Path specifies the exact path of the operations to select.
	Path pulumi.StringPtrInput `pulumi:"path"`
	// PathPrefix specifies the path prefix of the operations to select.
	PathPrefix pulumi.StringPtrInput `pulumi:"pathPrefix"`
	// PathRegex specifies a regular expression pattern for matching operations based on their paths.
	PathRegex pulumi.StringPtrInput `pulumi:"pathRegex"`
}

func (APISpecOpenApiSpecOperationSetsMatchersArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APISpecOpenApiSpecOperationSetsMatchers)(nil)).Elem()
}

func (i APISpecOpenApiSpecOperationSetsMatchersArgs) ToAPISpecOpenApiSpecOperationSetsMatchersOutput() APISpecOpenApiSpecOperationSetsMatchersOutput {
	return i.ToAPISpecOpenApiSpecOperationSetsMatchersOutputWithContext(context.Background())
}

func (i APISpecOpenApiSpecOperationSetsMatchersArgs) ToAPISpecOpenApiSpecOperationSetsMatchersOutputWithContext(ctx context.Context) APISpecOpenApiSpecOperationSetsMatchersOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APISpecOpenApiSpecOperationSetsMatchersOutput)
}

func (i APISpecOpenApiSpecOperationSetsMatchersArgs) ToOutput(ctx context.Context) pulumix.Output[APISpecOpenApiSpecOperationSetsMatchers] {
	return pulumix.Output[APISpecOpenApiSpecOperationSetsMatchers]{
		OutputState: i.ToAPISpecOpenApiSpecOperationSetsMatchersOutputWithContext(ctx).OutputState,
	}
}

// APISpecOpenApiSpecOperationSetsMatchersArrayInput is an input type that accepts APISpecOpenApiSpecOperationSetsMatchersArray and APISpecOpenApiSpecOperationSetsMatchersArrayOutput values.
// You can construct a concrete instance of `APISpecOpenApiSpecOperationSetsMatchersArrayInput` via:
//
//	APISpecOpenApiSpecOperationSetsMatchersArray{ APISpecOpenApiSpecOperationSetsMatchersArgs{...} }
type APISpecOpenApiSpecOperationSetsMatchersArrayInput interface {
	pulumi.Input

	ToAPISpecOpenApiSpecOperationSetsMatchersArrayOutput() APISpecOpenApiSpecOperationSetsMatchersArrayOutput
	ToAPISpecOpenApiSpecOperationSetsMatchersArrayOutputWithContext(context.Context) APISpecOpenApiSpecOperationSetsMatchersArrayOutput
}

type APISpecOpenApiSpecOperationSetsMatchersArray []APISpecOpenApiSpecOperationSetsMatchersInput

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

func (i APISpecOpenApiSpecOperationSetsMatchersArray) ToAPISpecOpenApiSpecOperationSetsMatchersArrayOutput() APISpecOpenApiSpecOperationSetsMatchersArrayOutput {
	return i.ToAPISpecOpenApiSpecOperationSetsMatchersArrayOutputWithContext(context.Background())
}

func (i APISpecOpenApiSpecOperationSetsMatchersArray) ToAPISpecOpenApiSpecOperationSetsMatchersArrayOutputWithContext(ctx context.Context) APISpecOpenApiSpecOperationSetsMatchersArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APISpecOpenApiSpecOperationSetsMatchersArrayOutput)
}

func (i APISpecOpenApiSpecOperationSetsMatchersArray) ToOutput(ctx context.Context) pulumix.Output[[]APISpecOpenApiSpecOperationSetsMatchers] {
	return pulumix.Output[[]APISpecOpenApiSpecOperationSetsMatchers]{
		OutputState: i.ToAPISpecOpenApiSpecOperationSetsMatchersArrayOutputWithContext(ctx).OutputState,
	}
}

// OperationMatcher defines criteria for matching an OpenAPI operation.
type APISpecOpenApiSpecOperationSetsMatchersOutput struct{ *pulumi.OutputState }

func (APISpecOpenApiSpecOperationSetsMatchersOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APISpecOpenApiSpecOperationSetsMatchers)(nil)).Elem()
}

func (o APISpecOpenApiSpecOperationSetsMatchersOutput) ToAPISpecOpenApiSpecOperationSetsMatchersOutput() APISpecOpenApiSpecOperationSetsMatchersOutput {
	return o
}

func (o APISpecOpenApiSpecOperationSetsMatchersOutput) ToAPISpecOpenApiSpecOperationSetsMatchersOutputWithContext(ctx context.Context) APISpecOpenApiSpecOperationSetsMatchersOutput {
	return o
}

func (o APISpecOpenApiSpecOperationSetsMatchersOutput) ToOutput(ctx context.Context) pulumix.Output[APISpecOpenApiSpecOperationSetsMatchers] {
	return pulumix.Output[APISpecOpenApiSpecOperationSetsMatchers]{
		OutputState: o.OutputState,
	}
}

// Methods specifies the HTTP methods to be included for selection.
func (o APISpecOpenApiSpecOperationSetsMatchersOutput) Methods() pulumi.StringArrayOutput {
	return o.ApplyT(func(v APISpecOpenApiSpecOperationSetsMatchers) []string { return v.Methods }).(pulumi.StringArrayOutput)
}

// Path specifies the exact path of the operations to select.
func (o APISpecOpenApiSpecOperationSetsMatchersOutput) Path() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APISpecOpenApiSpecOperationSetsMatchers) *string { return v.Path }).(pulumi.StringPtrOutput)
}

// PathPrefix specifies the path prefix of the operations to select.
func (o APISpecOpenApiSpecOperationSetsMatchersOutput) PathPrefix() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APISpecOpenApiSpecOperationSetsMatchers) *string { return v.PathPrefix }).(pulumi.StringPtrOutput)
}

// PathRegex specifies a regular expression pattern for matching operations based on their paths.
func (o APISpecOpenApiSpecOperationSetsMatchersOutput) PathRegex() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APISpecOpenApiSpecOperationSetsMatchers) *string { return v.PathRegex }).(pulumi.StringPtrOutput)
}

type APISpecOpenApiSpecOperationSetsMatchersArrayOutput struct{ *pulumi.OutputState }

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

func (o APISpecOpenApiSpecOperationSetsMatchersArrayOutput) ToAPISpecOpenApiSpecOperationSetsMatchersArrayOutput() APISpecOpenApiSpecOperationSetsMatchersArrayOutput {
	return o
}

func (o APISpecOpenApiSpecOperationSetsMatchersArrayOutput) ToAPISpecOpenApiSpecOperationSetsMatchersArrayOutputWithContext(ctx context.Context) APISpecOpenApiSpecOperationSetsMatchersArrayOutput {
	return o
}

func (o APISpecOpenApiSpecOperationSetsMatchersArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]APISpecOpenApiSpecOperationSetsMatchers] {
	return pulumix.Output[[]APISpecOpenApiSpecOperationSetsMatchers]{
		OutputState: o.OutputState,
	}
}

func (o APISpecOpenApiSpecOperationSetsMatchersArrayOutput) Index(i pulumi.IntInput) APISpecOpenApiSpecOperationSetsMatchersOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) APISpecOpenApiSpecOperationSetsMatchers {
		return vs[0].([]APISpecOpenApiSpecOperationSetsMatchers)[vs[1].(int)]
	}).(APISpecOpenApiSpecOperationSetsMatchersOutput)
}

// Override holds data used to override OpenAPI specification.
type APISpecOpenApiSpecOverride struct {
	Servers []APISpecOpenApiSpecOverrideServers `pulumi:"servers"`
}

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

	ToAPISpecOpenApiSpecOverrideOutput() APISpecOpenApiSpecOverrideOutput
	ToAPISpecOpenApiSpecOverrideOutputWithContext(context.Context) APISpecOpenApiSpecOverrideOutput
}

// Override holds data used to override OpenAPI specification.
type APISpecOpenApiSpecOverrideArgs struct {
	Servers APISpecOpenApiSpecOverrideServersArrayInput `pulumi:"servers"`
}

func (APISpecOpenApiSpecOverrideArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APISpecOpenApiSpecOverride)(nil)).Elem()
}

func (i APISpecOpenApiSpecOverrideArgs) ToAPISpecOpenApiSpecOverrideOutput() APISpecOpenApiSpecOverrideOutput {
	return i.ToAPISpecOpenApiSpecOverrideOutputWithContext(context.Background())
}

func (i APISpecOpenApiSpecOverrideArgs) ToAPISpecOpenApiSpecOverrideOutputWithContext(ctx context.Context) APISpecOpenApiSpecOverrideOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APISpecOpenApiSpecOverrideOutput)
}

func (i APISpecOpenApiSpecOverrideArgs) ToOutput(ctx context.Context) pulumix.Output[APISpecOpenApiSpecOverride] {
	return pulumix.Output[APISpecOpenApiSpecOverride]{
		OutputState: i.ToAPISpecOpenApiSpecOverrideOutputWithContext(ctx).OutputState,
	}
}

func (i APISpecOpenApiSpecOverrideArgs) ToAPISpecOpenApiSpecOverridePtrOutput() APISpecOpenApiSpecOverridePtrOutput {
	return i.ToAPISpecOpenApiSpecOverridePtrOutputWithContext(context.Background())
}

func (i APISpecOpenApiSpecOverrideArgs) ToAPISpecOpenApiSpecOverridePtrOutputWithContext(ctx context.Context) APISpecOpenApiSpecOverridePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APISpecOpenApiSpecOverrideOutput).ToAPISpecOpenApiSpecOverridePtrOutputWithContext(ctx)
}

// APISpecOpenApiSpecOverridePtrInput is an input type that accepts APISpecOpenApiSpecOverrideArgs, APISpecOpenApiSpecOverridePtr and APISpecOpenApiSpecOverridePtrOutput values.
// You can construct a concrete instance of `APISpecOpenApiSpecOverridePtrInput` via:
//
//	        APISpecOpenApiSpecOverrideArgs{...}
//
//	or:
//
//	        nil
type APISpecOpenApiSpecOverridePtrInput interface {
	pulumi.Input

	ToAPISpecOpenApiSpecOverridePtrOutput() APISpecOpenApiSpecOverridePtrOutput
	ToAPISpecOpenApiSpecOverridePtrOutputWithContext(context.Context) APISpecOpenApiSpecOverridePtrOutput
}

type apispecOpenApiSpecOverridePtrType APISpecOpenApiSpecOverrideArgs

func APISpecOpenApiSpecOverridePtr(v *APISpecOpenApiSpecOverrideArgs) APISpecOpenApiSpecOverridePtrInput {
	return (*apispecOpenApiSpecOverridePtrType)(v)
}

func (*apispecOpenApiSpecOverridePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**APISpecOpenApiSpecOverride)(nil)).Elem()
}

func (i *apispecOpenApiSpecOverridePtrType) ToAPISpecOpenApiSpecOverridePtrOutput() APISpecOpenApiSpecOverridePtrOutput {
	return i.ToAPISpecOpenApiSpecOverridePtrOutputWithContext(context.Background())
}

func (i *apispecOpenApiSpecOverridePtrType) ToAPISpecOpenApiSpecOverridePtrOutputWithContext(ctx context.Context) APISpecOpenApiSpecOverridePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APISpecOpenApiSpecOverridePtrOutput)
}

func (i *apispecOpenApiSpecOverridePtrType) ToOutput(ctx context.Context) pulumix.Output[*APISpecOpenApiSpecOverride] {
	return pulumix.Output[*APISpecOpenApiSpecOverride]{
		OutputState: i.ToAPISpecOpenApiSpecOverridePtrOutputWithContext(ctx).OutputState,
	}
}

// Override holds data used to override OpenAPI specification.
type APISpecOpenApiSpecOverrideOutput struct{ *pulumi.OutputState }

func (APISpecOpenApiSpecOverrideOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APISpecOpenApiSpecOverride)(nil)).Elem()
}

func (o APISpecOpenApiSpecOverrideOutput) ToAPISpecOpenApiSpecOverrideOutput() APISpecOpenApiSpecOverrideOutput {
	return o
}

func (o APISpecOpenApiSpecOverrideOutput) ToAPISpecOpenApiSpecOverrideOutputWithContext(ctx context.Context) APISpecOpenApiSpecOverrideOutput {
	return o
}

func (o APISpecOpenApiSpecOverrideOutput) ToAPISpecOpenApiSpecOverridePtrOutput() APISpecOpenApiSpecOverridePtrOutput {
	return o.ToAPISpecOpenApiSpecOverridePtrOutputWithContext(context.Background())
}

func (o APISpecOpenApiSpecOverrideOutput) ToAPISpecOpenApiSpecOverridePtrOutputWithContext(ctx context.Context) APISpecOpenApiSpecOverridePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v APISpecOpenApiSpecOverride) *APISpecOpenApiSpecOverride {
		return &v
	}).(APISpecOpenApiSpecOverridePtrOutput)
}

func (o APISpecOpenApiSpecOverrideOutput) ToOutput(ctx context.Context) pulumix.Output[APISpecOpenApiSpecOverride] {
	return pulumix.Output[APISpecOpenApiSpecOverride]{
		OutputState: o.OutputState,
	}
}

func (o APISpecOpenApiSpecOverrideOutput) Servers() APISpecOpenApiSpecOverrideServersArrayOutput {
	return o.ApplyT(func(v APISpecOpenApiSpecOverride) []APISpecOpenApiSpecOverrideServers { return v.Servers }).(APISpecOpenApiSpecOverrideServersArrayOutput)
}

type APISpecOpenApiSpecOverridePtrOutput struct{ *pulumi.OutputState }

func (APISpecOpenApiSpecOverridePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**APISpecOpenApiSpecOverride)(nil)).Elem()
}

func (o APISpecOpenApiSpecOverridePtrOutput) ToAPISpecOpenApiSpecOverridePtrOutput() APISpecOpenApiSpecOverridePtrOutput {
	return o
}

func (o APISpecOpenApiSpecOverridePtrOutput) ToAPISpecOpenApiSpecOverridePtrOutputWithContext(ctx context.Context) APISpecOpenApiSpecOverridePtrOutput {
	return o
}

func (o APISpecOpenApiSpecOverridePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*APISpecOpenApiSpecOverride] {
	return pulumix.Output[*APISpecOpenApiSpecOverride]{
		OutputState: o.OutputState,
	}
}

func (o APISpecOpenApiSpecOverridePtrOutput) Elem() APISpecOpenApiSpecOverrideOutput {
	return o.ApplyT(func(v *APISpecOpenApiSpecOverride) APISpecOpenApiSpecOverride {
		if v != nil {
			return *v
		}
		var ret APISpecOpenApiSpecOverride
		return ret
	}).(APISpecOpenApiSpecOverrideOutput)
}

func (o APISpecOpenApiSpecOverridePtrOutput) Servers() APISpecOpenApiSpecOverrideServersArrayOutput {
	return o.ApplyT(func(v *APISpecOpenApiSpecOverride) []APISpecOpenApiSpecOverrideServers {
		if v == nil {
			return nil
		}
		return v.Servers
	}).(APISpecOpenApiSpecOverrideServersArrayOutput)
}

type APISpecOpenApiSpecOverrideServers struct {
	Url string `pulumi:"url"`
}

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

	ToAPISpecOpenApiSpecOverrideServersOutput() APISpecOpenApiSpecOverrideServersOutput
	ToAPISpecOpenApiSpecOverrideServersOutputWithContext(context.Context) APISpecOpenApiSpecOverrideServersOutput
}

type APISpecOpenApiSpecOverrideServersArgs struct {
	Url pulumi.StringInput `pulumi:"url"`
}

func (APISpecOpenApiSpecOverrideServersArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APISpecOpenApiSpecOverrideServers)(nil)).Elem()
}

func (i APISpecOpenApiSpecOverrideServersArgs) ToAPISpecOpenApiSpecOverrideServersOutput() APISpecOpenApiSpecOverrideServersOutput {
	return i.ToAPISpecOpenApiSpecOverrideServersOutputWithContext(context.Background())
}

func (i APISpecOpenApiSpecOverrideServersArgs) ToAPISpecOpenApiSpecOverrideServersOutputWithContext(ctx context.Context) APISpecOpenApiSpecOverrideServersOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APISpecOpenApiSpecOverrideServersOutput)
}

func (i APISpecOpenApiSpecOverrideServersArgs) ToOutput(ctx context.Context) pulumix.Output[APISpecOpenApiSpecOverrideServers] {
	return pulumix.Output[APISpecOpenApiSpecOverrideServers]{
		OutputState: i.ToAPISpecOpenApiSpecOverrideServersOutputWithContext(ctx).OutputState,
	}
}

// APISpecOpenApiSpecOverrideServersArrayInput is an input type that accepts APISpecOpenApiSpecOverrideServersArray and APISpecOpenApiSpecOverrideServersArrayOutput values.
// You can construct a concrete instance of `APISpecOpenApiSpecOverrideServersArrayInput` via:
//
//	APISpecOpenApiSpecOverrideServersArray{ APISpecOpenApiSpecOverrideServersArgs{...} }
type APISpecOpenApiSpecOverrideServersArrayInput interface {
	pulumi.Input

	ToAPISpecOpenApiSpecOverrideServersArrayOutput() APISpecOpenApiSpecOverrideServersArrayOutput
	ToAPISpecOpenApiSpecOverrideServersArrayOutputWithContext(context.Context) APISpecOpenApiSpecOverrideServersArrayOutput
}

type APISpecOpenApiSpecOverrideServersArray []APISpecOpenApiSpecOverrideServersInput

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

func (i APISpecOpenApiSpecOverrideServersArray) ToAPISpecOpenApiSpecOverrideServersArrayOutput() APISpecOpenApiSpecOverrideServersArrayOutput {
	return i.ToAPISpecOpenApiSpecOverrideServersArrayOutputWithContext(context.Background())
}

func (i APISpecOpenApiSpecOverrideServersArray) ToAPISpecOpenApiSpecOverrideServersArrayOutputWithContext(ctx context.Context) APISpecOpenApiSpecOverrideServersArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APISpecOpenApiSpecOverrideServersArrayOutput)
}

func (i APISpecOpenApiSpecOverrideServersArray) ToOutput(ctx context.Context) pulumix.Output[[]APISpecOpenApiSpecOverrideServers] {
	return pulumix.Output[[]APISpecOpenApiSpecOverrideServers]{
		OutputState: i.ToAPISpecOpenApiSpecOverrideServersArrayOutputWithContext(ctx).OutputState,
	}
}

type APISpecOpenApiSpecOverrideServersOutput struct{ *pulumi.OutputState }

func (APISpecOpenApiSpecOverrideServersOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APISpecOpenApiSpecOverrideServers)(nil)).Elem()
}

func (o APISpecOpenApiSpecOverrideServersOutput) ToAPISpecOpenApiSpecOverrideServersOutput() APISpecOpenApiSpecOverrideServersOutput {
	return o
}

func (o APISpecOpenApiSpecOverrideServersOutput) ToAPISpecOpenApiSpecOverrideServersOutputWithContext(ctx context.Context) APISpecOpenApiSpecOverrideServersOutput {
	return o
}

func (o APISpecOpenApiSpecOverrideServersOutput) ToOutput(ctx context.Context) pulumix.Output[APISpecOpenApiSpecOverrideServers] {
	return pulumix.Output[APISpecOpenApiSpecOverrideServers]{
		OutputState: o.OutputState,
	}
}

func (o APISpecOpenApiSpecOverrideServersOutput) Url() pulumi.StringOutput {
	return o.ApplyT(func(v APISpecOpenApiSpecOverrideServers) string { return v.Url }).(pulumi.StringOutput)
}

type APISpecOpenApiSpecOverrideServersArrayOutput struct{ *pulumi.OutputState }

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

func (o APISpecOpenApiSpecOverrideServersArrayOutput) ToAPISpecOpenApiSpecOverrideServersArrayOutput() APISpecOpenApiSpecOverrideServersArrayOutput {
	return o
}

func (o APISpecOpenApiSpecOverrideServersArrayOutput) ToAPISpecOpenApiSpecOverrideServersArrayOutputWithContext(ctx context.Context) APISpecOpenApiSpecOverrideServersArrayOutput {
	return o
}

func (o APISpecOpenApiSpecOverrideServersArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]APISpecOpenApiSpecOverrideServers] {
	return pulumix.Output[[]APISpecOpenApiSpecOverrideServers]{
		OutputState: o.OutputState,
	}
}

func (o APISpecOpenApiSpecOverrideServersArrayOutput) Index(i pulumi.IntInput) APISpecOpenApiSpecOverrideServersOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) APISpecOpenApiSpecOverrideServers {
		return vs[0].([]APISpecOpenApiSpecOverrideServers)[vs[1].(int)]
	}).(APISpecOpenApiSpecOverrideServersOutput)
}

// APIVersionRef references an APIVersion.
type APISpecVersions struct {
	// Name of the APIVersion.
	Name string `pulumi:"name"`
}

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

	ToAPISpecVersionsOutput() APISpecVersionsOutput
	ToAPISpecVersionsOutputWithContext(context.Context) APISpecVersionsOutput
}

// APIVersionRef references an APIVersion.
type APISpecVersionsArgs struct {
	// Name of the APIVersion.
	Name pulumi.StringInput `pulumi:"name"`
}

func (APISpecVersionsArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APISpecVersions)(nil)).Elem()
}

func (i APISpecVersionsArgs) ToAPISpecVersionsOutput() APISpecVersionsOutput {
	return i.ToAPISpecVersionsOutputWithContext(context.Background())
}

func (i APISpecVersionsArgs) ToAPISpecVersionsOutputWithContext(ctx context.Context) APISpecVersionsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APISpecVersionsOutput)
}

func (i APISpecVersionsArgs) ToOutput(ctx context.Context) pulumix.Output[APISpecVersions] {
	return pulumix.Output[APISpecVersions]{
		OutputState: i.ToAPISpecVersionsOutputWithContext(ctx).OutputState,
	}
}

// APISpecVersionsArrayInput is an input type that accepts APISpecVersionsArray and APISpecVersionsArrayOutput values.
// You can construct a concrete instance of `APISpecVersionsArrayInput` via:
//
//	APISpecVersionsArray{ APISpecVersionsArgs{...} }
type APISpecVersionsArrayInput interface {
	pulumi.Input

	ToAPISpecVersionsArrayOutput() APISpecVersionsArrayOutput
	ToAPISpecVersionsArrayOutputWithContext(context.Context) APISpecVersionsArrayOutput
}

type APISpecVersionsArray []APISpecVersionsInput

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

func (i APISpecVersionsArray) ToAPISpecVersionsArrayOutput() APISpecVersionsArrayOutput {
	return i.ToAPISpecVersionsArrayOutputWithContext(context.Background())
}

func (i APISpecVersionsArray) ToAPISpecVersionsArrayOutputWithContext(ctx context.Context) APISpecVersionsArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APISpecVersionsArrayOutput)
}

func (i APISpecVersionsArray) ToOutput(ctx context.Context) pulumix.Output[[]APISpecVersions] {
	return pulumix.Output[[]APISpecVersions]{
		OutputState: i.ToAPISpecVersionsArrayOutputWithContext(ctx).OutputState,
	}
}

// APIVersionRef references an APIVersion.
type APISpecVersionsOutput struct{ *pulumi.OutputState }

func (APISpecVersionsOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APISpecVersions)(nil)).Elem()
}

func (o APISpecVersionsOutput) ToAPISpecVersionsOutput() APISpecVersionsOutput {
	return o
}

func (o APISpecVersionsOutput) ToAPISpecVersionsOutputWithContext(ctx context.Context) APISpecVersionsOutput {
	return o
}

func (o APISpecVersionsOutput) ToOutput(ctx context.Context) pulumix.Output[APISpecVersions] {
	return pulumix.Output[APISpecVersions]{
		OutputState: o.OutputState,
	}
}

// Name of the APIVersion.
func (o APISpecVersionsOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v APISpecVersions) string { return v.Name }).(pulumi.StringOutput)
}

type APISpecVersionsArrayOutput struct{ *pulumi.OutputState }

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

func (o APISpecVersionsArrayOutput) ToAPISpecVersionsArrayOutput() APISpecVersionsArrayOutput {
	return o
}

func (o APISpecVersionsArrayOutput) ToAPISpecVersionsArrayOutputWithContext(ctx context.Context) APISpecVersionsArrayOutput {
	return o
}

func (o APISpecVersionsArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]APISpecVersions] {
	return pulumix.Output[[]APISpecVersions]{
		OutputState: o.OutputState,
	}
}

func (o APISpecVersionsArrayOutput) Index(i pulumi.IntInput) APISpecVersionsOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) APISpecVersions {
		return vs[0].([]APISpecVersions)[vs[1].(int)]
	}).(APISpecVersionsOutput)
}

// The current status of this API.
type APIStatus struct {
	// Hash is a hash representing the API.
	Hash     *string `pulumi:"hash"`
	SyncedAt *string `pulumi:"syncedAt"`
	Version  *string `pulumi:"version"`
}

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

	ToAPIStatusOutput() APIStatusOutput
	ToAPIStatusOutputWithContext(context.Context) APIStatusOutput
}

// The current status of this API.
type APIStatusArgs struct {
	// Hash is a hash representing the API.
	Hash     pulumi.StringPtrInput `pulumi:"hash"`
	SyncedAt pulumi.StringPtrInput `pulumi:"syncedAt"`
	Version  pulumi.StringPtrInput `pulumi:"version"`
}

func (APIStatusArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APIStatus)(nil)).Elem()
}

func (i APIStatusArgs) ToAPIStatusOutput() APIStatusOutput {
	return i.ToAPIStatusOutputWithContext(context.Background())
}

func (i APIStatusArgs) ToAPIStatusOutputWithContext(ctx context.Context) APIStatusOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIStatusOutput)
}

func (i APIStatusArgs) ToOutput(ctx context.Context) pulumix.Output[APIStatus] {
	return pulumix.Output[APIStatus]{
		OutputState: i.ToAPIStatusOutputWithContext(ctx).OutputState,
	}
}

func (i APIStatusArgs) ToAPIStatusPtrOutput() APIStatusPtrOutput {
	return i.ToAPIStatusPtrOutputWithContext(context.Background())
}

func (i APIStatusArgs) ToAPIStatusPtrOutputWithContext(ctx context.Context) APIStatusPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIStatusOutput).ToAPIStatusPtrOutputWithContext(ctx)
}

// APIStatusPtrInput is an input type that accepts APIStatusArgs, APIStatusPtr and APIStatusPtrOutput values.
// You can construct a concrete instance of `APIStatusPtrInput` via:
//
//	        APIStatusArgs{...}
//
//	or:
//
//	        nil
type APIStatusPtrInput interface {
	pulumi.Input

	ToAPIStatusPtrOutput() APIStatusPtrOutput
	ToAPIStatusPtrOutputWithContext(context.Context) APIStatusPtrOutput
}

type apistatusPtrType APIStatusArgs

func APIStatusPtr(v *APIStatusArgs) APIStatusPtrInput {
	return (*apistatusPtrType)(v)
}

func (*apistatusPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**APIStatus)(nil)).Elem()
}

func (i *apistatusPtrType) ToAPIStatusPtrOutput() APIStatusPtrOutput {
	return i.ToAPIStatusPtrOutputWithContext(context.Background())
}

func (i *apistatusPtrType) ToAPIStatusPtrOutputWithContext(ctx context.Context) APIStatusPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIStatusPtrOutput)
}

func (i *apistatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*APIStatus] {
	return pulumix.Output[*APIStatus]{
		OutputState: i.ToAPIStatusPtrOutputWithContext(ctx).OutputState,
	}
}

// The current status of this API.
type APIStatusOutput struct{ *pulumi.OutputState }

func (APIStatusOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APIStatus)(nil)).Elem()
}

func (o APIStatusOutput) ToAPIStatusOutput() APIStatusOutput {
	return o
}

func (o APIStatusOutput) ToAPIStatusOutputWithContext(ctx context.Context) APIStatusOutput {
	return o
}

func (o APIStatusOutput) ToAPIStatusPtrOutput() APIStatusPtrOutput {
	return o.ToAPIStatusPtrOutputWithContext(context.Background())
}

func (o APIStatusOutput) ToAPIStatusPtrOutputWithContext(ctx context.Context) APIStatusPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v APIStatus) *APIStatus {
		return &v
	}).(APIStatusPtrOutput)
}

func (o APIStatusOutput) ToOutput(ctx context.Context) pulumix.Output[APIStatus] {
	return pulumix.Output[APIStatus]{
		OutputState: o.OutputState,
	}
}

// Hash is a hash representing the API.
func (o APIStatusOutput) Hash() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIStatus) *string { return v.Hash }).(pulumi.StringPtrOutput)
}

func (o APIStatusOutput) SyncedAt() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIStatus) *string { return v.SyncedAt }).(pulumi.StringPtrOutput)
}

func (o APIStatusOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIStatus) *string { return v.Version }).(pulumi.StringPtrOutput)
}

type APIStatusPtrOutput struct{ *pulumi.OutputState }

func (APIStatusPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**APIStatus)(nil)).Elem()
}

func (o APIStatusPtrOutput) ToAPIStatusPtrOutput() APIStatusPtrOutput {
	return o
}

func (o APIStatusPtrOutput) ToAPIStatusPtrOutputWithContext(ctx context.Context) APIStatusPtrOutput {
	return o
}

func (o APIStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*APIStatus] {
	return pulumix.Output[*APIStatus]{
		OutputState: o.OutputState,
	}
}

func (o APIStatusPtrOutput) Elem() APIStatusOutput {
	return o.ApplyT(func(v *APIStatus) APIStatus {
		if v != nil {
			return *v
		}
		var ret APIStatus
		return ret
	}).(APIStatusOutput)
}

// Hash is a hash representing the API.
func (o APIStatusPtrOutput) Hash() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIStatus) *string {
		if v == nil {
			return nil
		}
		return v.Hash
	}).(pulumi.StringPtrOutput)
}

func (o APIStatusPtrOutput) SyncedAt() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIStatus) *string {
		if v == nil {
			return nil
		}
		return v.SyncedAt
	}).(pulumi.StringPtrOutput)
}

func (o APIStatusPtrOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIStatus) *string {
		if v == nil {
			return nil
		}
		return v.Version
	}).(pulumi.StringPtrOutput)
}

// APIVersion defines a version of an API.
type APIVersionType struct {
	ApiVersion *string        `pulumi:"apiVersion"`
	Kind       *string        `pulumi:"kind"`
	Metadata   *v1.ObjectMeta `pulumi:"metadata"`
	// The desired behavior of this APIVersion.
	Spec *APIVersionSpec `pulumi:"spec"`
	// The current status of this APIVersion.
	Status *APIVersionStatus `pulumi:"status"`
}

type APIVersionMetadata struct {
}

// The desired behavior of this APIVersion.
type APIVersionSpec struct {
	// OpenAPISpec defines the API contract as an OpenAPI specification.
	OpenApiSpec *APIVersionSpecOpenApiSpec `pulumi:"openApiSpec"`
	// Release is the version number of the API.
	// This value must follow the SemVer format: https://semver.org/
	Release string `pulumi:"release"`
	// Title is the public facing name of the APIVersion.
	Title *string `pulumi:"title"`
}

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

	ToAPIVersionSpecOutput() APIVersionSpecOutput
	ToAPIVersionSpecOutputWithContext(context.Context) APIVersionSpecOutput
}

// The desired behavior of this APIVersion.
type APIVersionSpecArgs struct {
	// OpenAPISpec defines the API contract as an OpenAPI specification.
	OpenApiSpec APIVersionSpecOpenApiSpecPtrInput `pulumi:"openApiSpec"`
	// Release is the version number of the API.
	// This value must follow the SemVer format: https://semver.org/
	Release pulumi.StringInput `pulumi:"release"`
	// Title is the public facing name of the APIVersion.
	Title pulumi.StringPtrInput `pulumi:"title"`
}

func (APIVersionSpecArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APIVersionSpec)(nil)).Elem()
}

func (i APIVersionSpecArgs) ToAPIVersionSpecOutput() APIVersionSpecOutput {
	return i.ToAPIVersionSpecOutputWithContext(context.Background())
}

func (i APIVersionSpecArgs) ToAPIVersionSpecOutputWithContext(ctx context.Context) APIVersionSpecOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIVersionSpecOutput)
}

func (i APIVersionSpecArgs) ToOutput(ctx context.Context) pulumix.Output[APIVersionSpec] {
	return pulumix.Output[APIVersionSpec]{
		OutputState: i.ToAPIVersionSpecOutputWithContext(ctx).OutputState,
	}
}

func (i APIVersionSpecArgs) ToAPIVersionSpecPtrOutput() APIVersionSpecPtrOutput {
	return i.ToAPIVersionSpecPtrOutputWithContext(context.Background())
}

func (i APIVersionSpecArgs) ToAPIVersionSpecPtrOutputWithContext(ctx context.Context) APIVersionSpecPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIVersionSpecOutput).ToAPIVersionSpecPtrOutputWithContext(ctx)
}

// APIVersionSpecPtrInput is an input type that accepts APIVersionSpecArgs, APIVersionSpecPtr and APIVersionSpecPtrOutput values.
// You can construct a concrete instance of `APIVersionSpecPtrInput` via:
//
//	        APIVersionSpecArgs{...}
//
//	or:
//
//	        nil
type APIVersionSpecPtrInput interface {
	pulumi.Input

	ToAPIVersionSpecPtrOutput() APIVersionSpecPtrOutput
	ToAPIVersionSpecPtrOutputWithContext(context.Context) APIVersionSpecPtrOutput
}

type apiversionSpecPtrType APIVersionSpecArgs

func APIVersionSpecPtr(v *APIVersionSpecArgs) APIVersionSpecPtrInput {
	return (*apiversionSpecPtrType)(v)
}

func (*apiversionSpecPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**APIVersionSpec)(nil)).Elem()
}

func (i *apiversionSpecPtrType) ToAPIVersionSpecPtrOutput() APIVersionSpecPtrOutput {
	return i.ToAPIVersionSpecPtrOutputWithContext(context.Background())
}

func (i *apiversionSpecPtrType) ToAPIVersionSpecPtrOutputWithContext(ctx context.Context) APIVersionSpecPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIVersionSpecPtrOutput)
}

func (i *apiversionSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*APIVersionSpec] {
	return pulumix.Output[*APIVersionSpec]{
		OutputState: i.ToAPIVersionSpecPtrOutputWithContext(ctx).OutputState,
	}
}

// The desired behavior of this APIVersion.
type APIVersionSpecOutput struct{ *pulumi.OutputState }

func (APIVersionSpecOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APIVersionSpec)(nil)).Elem()
}

func (o APIVersionSpecOutput) ToAPIVersionSpecOutput() APIVersionSpecOutput {
	return o
}

func (o APIVersionSpecOutput) ToAPIVersionSpecOutputWithContext(ctx context.Context) APIVersionSpecOutput {
	return o
}

func (o APIVersionSpecOutput) ToAPIVersionSpecPtrOutput() APIVersionSpecPtrOutput {
	return o.ToAPIVersionSpecPtrOutputWithContext(context.Background())
}

func (o APIVersionSpecOutput) ToAPIVersionSpecPtrOutputWithContext(ctx context.Context) APIVersionSpecPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v APIVersionSpec) *APIVersionSpec {
		return &v
	}).(APIVersionSpecPtrOutput)
}

func (o APIVersionSpecOutput) ToOutput(ctx context.Context) pulumix.Output[APIVersionSpec] {
	return pulumix.Output[APIVersionSpec]{
		OutputState: o.OutputState,
	}
}

// OpenAPISpec defines the API contract as an OpenAPI specification.
func (o APIVersionSpecOutput) OpenApiSpec() APIVersionSpecOpenApiSpecPtrOutput {
	return o.ApplyT(func(v APIVersionSpec) *APIVersionSpecOpenApiSpec { return v.OpenApiSpec }).(APIVersionSpecOpenApiSpecPtrOutput)
}

// Release is the version number of the API.
// This value must follow the SemVer format: https://semver.org/
func (o APIVersionSpecOutput) Release() pulumi.StringOutput {
	return o.ApplyT(func(v APIVersionSpec) string { return v.Release }).(pulumi.StringOutput)
}

// Title is the public facing name of the APIVersion.
func (o APIVersionSpecOutput) Title() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIVersionSpec) *string { return v.Title }).(pulumi.StringPtrOutput)
}

type APIVersionSpecPtrOutput struct{ *pulumi.OutputState }

func (APIVersionSpecPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**APIVersionSpec)(nil)).Elem()
}

func (o APIVersionSpecPtrOutput) ToAPIVersionSpecPtrOutput() APIVersionSpecPtrOutput {
	return o
}

func (o APIVersionSpecPtrOutput) ToAPIVersionSpecPtrOutputWithContext(ctx context.Context) APIVersionSpecPtrOutput {
	return o
}

func (o APIVersionSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*APIVersionSpec] {
	return pulumix.Output[*APIVersionSpec]{
		OutputState: o.OutputState,
	}
}

func (o APIVersionSpecPtrOutput) Elem() APIVersionSpecOutput {
	return o.ApplyT(func(v *APIVersionSpec) APIVersionSpec {
		if v != nil {
			return *v
		}
		var ret APIVersionSpec
		return ret
	}).(APIVersionSpecOutput)
}

// OpenAPISpec defines the API contract as an OpenAPI specification.
func (o APIVersionSpecPtrOutput) OpenApiSpec() APIVersionSpecOpenApiSpecPtrOutput {
	return o.ApplyT(func(v *APIVersionSpec) *APIVersionSpecOpenApiSpec {
		if v == nil {
			return nil
		}
		return v.OpenApiSpec
	}).(APIVersionSpecOpenApiSpecPtrOutput)
}

// Release is the version number of the API.
// This value must follow the SemVer format: https://semver.org/
func (o APIVersionSpecPtrOutput) Release() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIVersionSpec) *string {
		if v == nil {
			return nil
		}
		return &v.Release
	}).(pulumi.StringPtrOutput)
}

// Title is the public facing name of the APIVersion.
func (o APIVersionSpecPtrOutput) Title() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIVersionSpec) *string {
		if v == nil {
			return nil
		}
		return v.Title
	}).(pulumi.StringPtrOutput)
}

// OpenAPISpec defines the API contract as an OpenAPI specification.
type APIVersionSpecOpenApiSpec struct {
	// OperationSets defines the sets of operations to be referenced for granular filtering in APIAccesses.
	OperationSets []APIVersionSpecOpenApiSpecOperationSets `pulumi:"operationSets"`
	// Override holds data used to override OpenAPI specification.
	Override *APIVersionSpecOpenApiSpecOverride `pulumi:"override"`
	// Path specifies the endpoint path within the Kubernetes Service where the OpenAPI specification can be obtained.
	// The Service queried is determined by the associated Ingress, IngressRoute, or HTTPRoute resource to which the API is attached.
	// It's important to note that this option is incompatible if the Ingress or IngressRoute specifies multiple backend services.
	// The Path must be accessible via a GET request method and should serve a YAML or JSON document containing the OpenAPI specification.
	Path *string `pulumi:"path"`
	// URL is a Traefik Hub agent accessible URL for obtaining the OpenAPI specification.
	// The URL must be accessible via a GET request method and should serve a YAML or JSON document containing the OpenAPI specification.
	Url *string `pulumi:"url"`
}

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

	ToAPIVersionSpecOpenApiSpecOutput() APIVersionSpecOpenApiSpecOutput
	ToAPIVersionSpecOpenApiSpecOutputWithContext(context.Context) APIVersionSpecOpenApiSpecOutput
}

// OpenAPISpec defines the API contract as an OpenAPI specification.
type APIVersionSpecOpenApiSpecArgs struct {
	// OperationSets defines the sets of operations to be referenced for granular filtering in APIAccesses.
	OperationSets APIVersionSpecOpenApiSpecOperationSetsArrayInput `pulumi:"operationSets"`
	// Override holds data used to override OpenAPI specification.
	Override APIVersionSpecOpenApiSpecOverridePtrInput `pulumi:"override"`
	// Path specifies the endpoint path within the Kubernetes Service where the OpenAPI specification can be obtained.
	// The Service queried is determined by the associated Ingress, IngressRoute, or HTTPRoute resource to which the API is attached.
	// It's important to note that this option is incompatible if the Ingress or IngressRoute specifies multiple backend services.
	// The Path must be accessible via a GET request method and should serve a YAML or JSON document containing the OpenAPI specification.
	Path pulumi.StringPtrInput `pulumi:"path"`
	// URL is a Traefik Hub agent accessible URL for obtaining the OpenAPI specification.
	// The URL must be accessible via a GET request method and should serve a YAML or JSON document containing the OpenAPI specification.
	Url pulumi.StringPtrInput `pulumi:"url"`
}

func (APIVersionSpecOpenApiSpecArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APIVersionSpecOpenApiSpec)(nil)).Elem()
}

func (i APIVersionSpecOpenApiSpecArgs) ToAPIVersionSpecOpenApiSpecOutput() APIVersionSpecOpenApiSpecOutput {
	return i.ToAPIVersionSpecOpenApiSpecOutputWithContext(context.Background())
}

func (i APIVersionSpecOpenApiSpecArgs) ToAPIVersionSpecOpenApiSpecOutputWithContext(ctx context.Context) APIVersionSpecOpenApiSpecOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIVersionSpecOpenApiSpecOutput)
}

func (i APIVersionSpecOpenApiSpecArgs) ToOutput(ctx context.Context) pulumix.Output[APIVersionSpecOpenApiSpec] {
	return pulumix.Output[APIVersionSpecOpenApiSpec]{
		OutputState: i.ToAPIVersionSpecOpenApiSpecOutputWithContext(ctx).OutputState,
	}
}

func (i APIVersionSpecOpenApiSpecArgs) ToAPIVersionSpecOpenApiSpecPtrOutput() APIVersionSpecOpenApiSpecPtrOutput {
	return i.ToAPIVersionSpecOpenApiSpecPtrOutputWithContext(context.Background())
}

func (i APIVersionSpecOpenApiSpecArgs) ToAPIVersionSpecOpenApiSpecPtrOutputWithContext(ctx context.Context) APIVersionSpecOpenApiSpecPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIVersionSpecOpenApiSpecOutput).ToAPIVersionSpecOpenApiSpecPtrOutputWithContext(ctx)
}

// APIVersionSpecOpenApiSpecPtrInput is an input type that accepts APIVersionSpecOpenApiSpecArgs, APIVersionSpecOpenApiSpecPtr and APIVersionSpecOpenApiSpecPtrOutput values.
// You can construct a concrete instance of `APIVersionSpecOpenApiSpecPtrInput` via:
//
//	        APIVersionSpecOpenApiSpecArgs{...}
//
//	or:
//
//	        nil
type APIVersionSpecOpenApiSpecPtrInput interface {
	pulumi.Input

	ToAPIVersionSpecOpenApiSpecPtrOutput() APIVersionSpecOpenApiSpecPtrOutput
	ToAPIVersionSpecOpenApiSpecPtrOutputWithContext(context.Context) APIVersionSpecOpenApiSpecPtrOutput
}

type apiversionSpecOpenApiSpecPtrType APIVersionSpecOpenApiSpecArgs

func APIVersionSpecOpenApiSpecPtr(v *APIVersionSpecOpenApiSpecArgs) APIVersionSpecOpenApiSpecPtrInput {
	return (*apiversionSpecOpenApiSpecPtrType)(v)
}

func (*apiversionSpecOpenApiSpecPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**APIVersionSpecOpenApiSpec)(nil)).Elem()
}

func (i *apiversionSpecOpenApiSpecPtrType) ToAPIVersionSpecOpenApiSpecPtrOutput() APIVersionSpecOpenApiSpecPtrOutput {
	return i.ToAPIVersionSpecOpenApiSpecPtrOutputWithContext(context.Background())
}

func (i *apiversionSpecOpenApiSpecPtrType) ToAPIVersionSpecOpenApiSpecPtrOutputWithContext(ctx context.Context) APIVersionSpecOpenApiSpecPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIVersionSpecOpenApiSpecPtrOutput)
}

func (i *apiversionSpecOpenApiSpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*APIVersionSpecOpenApiSpec] {
	return pulumix.Output[*APIVersionSpecOpenApiSpec]{
		OutputState: i.ToAPIVersionSpecOpenApiSpecPtrOutputWithContext(ctx).OutputState,
	}
}

// OpenAPISpec defines the API contract as an OpenAPI specification.
type APIVersionSpecOpenApiSpecOutput struct{ *pulumi.OutputState }

func (APIVersionSpecOpenApiSpecOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APIVersionSpecOpenApiSpec)(nil)).Elem()
}

func (o APIVersionSpecOpenApiSpecOutput) ToAPIVersionSpecOpenApiSpecOutput() APIVersionSpecOpenApiSpecOutput {
	return o
}

func (o APIVersionSpecOpenApiSpecOutput) ToAPIVersionSpecOpenApiSpecOutputWithContext(ctx context.Context) APIVersionSpecOpenApiSpecOutput {
	return o
}

func (o APIVersionSpecOpenApiSpecOutput) ToAPIVersionSpecOpenApiSpecPtrOutput() APIVersionSpecOpenApiSpecPtrOutput {
	return o.ToAPIVersionSpecOpenApiSpecPtrOutputWithContext(context.Background())
}

func (o APIVersionSpecOpenApiSpecOutput) ToAPIVersionSpecOpenApiSpecPtrOutputWithContext(ctx context.Context) APIVersionSpecOpenApiSpecPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v APIVersionSpecOpenApiSpec) *APIVersionSpecOpenApiSpec {
		return &v
	}).(APIVersionSpecOpenApiSpecPtrOutput)
}

func (o APIVersionSpecOpenApiSpecOutput) ToOutput(ctx context.Context) pulumix.Output[APIVersionSpecOpenApiSpec] {
	return pulumix.Output[APIVersionSpecOpenApiSpec]{
		OutputState: o.OutputState,
	}
}

// OperationSets defines the sets of operations to be referenced for granular filtering in APIAccesses.
func (o APIVersionSpecOpenApiSpecOutput) OperationSets() APIVersionSpecOpenApiSpecOperationSetsArrayOutput {
	return o.ApplyT(func(v APIVersionSpecOpenApiSpec) []APIVersionSpecOpenApiSpecOperationSets { return v.OperationSets }).(APIVersionSpecOpenApiSpecOperationSetsArrayOutput)
}

// Override holds data used to override OpenAPI specification.
func (o APIVersionSpecOpenApiSpecOutput) Override() APIVersionSpecOpenApiSpecOverridePtrOutput {
	return o.ApplyT(func(v APIVersionSpecOpenApiSpec) *APIVersionSpecOpenApiSpecOverride { return v.Override }).(APIVersionSpecOpenApiSpecOverridePtrOutput)
}

// Path specifies the endpoint path within the Kubernetes Service where the OpenAPI specification can be obtained.
// The Service queried is determined by the associated Ingress, IngressRoute, or HTTPRoute resource to which the API is attached.
// It's important to note that this option is incompatible if the Ingress or IngressRoute specifies multiple backend services.
// The Path must be accessible via a GET request method and should serve a YAML or JSON document containing the OpenAPI specification.
func (o APIVersionSpecOpenApiSpecOutput) Path() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIVersionSpecOpenApiSpec) *string { return v.Path }).(pulumi.StringPtrOutput)
}

// URL is a Traefik Hub agent accessible URL for obtaining the OpenAPI specification.
// The URL must be accessible via a GET request method and should serve a YAML or JSON document containing the OpenAPI specification.
func (o APIVersionSpecOpenApiSpecOutput) Url() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIVersionSpecOpenApiSpec) *string { return v.Url }).(pulumi.StringPtrOutput)
}

type APIVersionSpecOpenApiSpecPtrOutput struct{ *pulumi.OutputState }

func (APIVersionSpecOpenApiSpecPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**APIVersionSpecOpenApiSpec)(nil)).Elem()
}

func (o APIVersionSpecOpenApiSpecPtrOutput) ToAPIVersionSpecOpenApiSpecPtrOutput() APIVersionSpecOpenApiSpecPtrOutput {
	return o
}

func (o APIVersionSpecOpenApiSpecPtrOutput) ToAPIVersionSpecOpenApiSpecPtrOutputWithContext(ctx context.Context) APIVersionSpecOpenApiSpecPtrOutput {
	return o
}

func (o APIVersionSpecOpenApiSpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*APIVersionSpecOpenApiSpec] {
	return pulumix.Output[*APIVersionSpecOpenApiSpec]{
		OutputState: o.OutputState,
	}
}

func (o APIVersionSpecOpenApiSpecPtrOutput) Elem() APIVersionSpecOpenApiSpecOutput {
	return o.ApplyT(func(v *APIVersionSpecOpenApiSpec) APIVersionSpecOpenApiSpec {
		if v != nil {
			return *v
		}
		var ret APIVersionSpecOpenApiSpec
		return ret
	}).(APIVersionSpecOpenApiSpecOutput)
}

// OperationSets defines the sets of operations to be referenced for granular filtering in APIAccesses.
func (o APIVersionSpecOpenApiSpecPtrOutput) OperationSets() APIVersionSpecOpenApiSpecOperationSetsArrayOutput {
	return o.ApplyT(func(v *APIVersionSpecOpenApiSpec) []APIVersionSpecOpenApiSpecOperationSets {
		if v == nil {
			return nil
		}
		return v.OperationSets
	}).(APIVersionSpecOpenApiSpecOperationSetsArrayOutput)
}

// Override holds data used to override OpenAPI specification.
func (o APIVersionSpecOpenApiSpecPtrOutput) Override() APIVersionSpecOpenApiSpecOverridePtrOutput {
	return o.ApplyT(func(v *APIVersionSpecOpenApiSpec) *APIVersionSpecOpenApiSpecOverride {
		if v == nil {
			return nil
		}
		return v.Override
	}).(APIVersionSpecOpenApiSpecOverridePtrOutput)
}

// Path specifies the endpoint path within the Kubernetes Service where the OpenAPI specification can be obtained.
// The Service queried is determined by the associated Ingress, IngressRoute, or HTTPRoute resource to which the API is attached.
// It's important to note that this option is incompatible if the Ingress or IngressRoute specifies multiple backend services.
// The Path must be accessible via a GET request method and should serve a YAML or JSON document containing the OpenAPI specification.
func (o APIVersionSpecOpenApiSpecPtrOutput) Path() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIVersionSpecOpenApiSpec) *string {
		if v == nil {
			return nil
		}
		return v.Path
	}).(pulumi.StringPtrOutput)
}

// URL is a Traefik Hub agent accessible URL for obtaining the OpenAPI specification.
// The URL must be accessible via a GET request method and should serve a YAML or JSON document containing the OpenAPI specification.
func (o APIVersionSpecOpenApiSpecPtrOutput) Url() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIVersionSpecOpenApiSpec) *string {
		if v == nil {
			return nil
		}
		return v.Url
	}).(pulumi.StringPtrOutput)
}

// OperationSet gives a name to a set of matching OpenAPI operations.
// This set of operations can then be referenced for granular filtering in APIAccesses.
type APIVersionSpecOpenApiSpecOperationSets struct {
	// Matchers defines a list of alternative rules for matching OpenAPI operations.
	Matchers []APIVersionSpecOpenApiSpecOperationSetsMatchers `pulumi:"matchers"`
	// Name is the name of the OperationSet to reference in APIAccesses.
	Name string `pulumi:"name"`
}

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

	ToAPIVersionSpecOpenApiSpecOperationSetsOutput() APIVersionSpecOpenApiSpecOperationSetsOutput
	ToAPIVersionSpecOpenApiSpecOperationSetsOutputWithContext(context.Context) APIVersionSpecOpenApiSpecOperationSetsOutput
}

// OperationSet gives a name to a set of matching OpenAPI operations.
// This set of operations can then be referenced for granular filtering in APIAccesses.
type APIVersionSpecOpenApiSpecOperationSetsArgs struct {
	// Matchers defines a list of alternative rules for matching OpenAPI operations.
	Matchers APIVersionSpecOpenApiSpecOperationSetsMatchersArrayInput `pulumi:"matchers"`
	// Name is the name of the OperationSet to reference in APIAccesses.
	Name pulumi.StringInput `pulumi:"name"`
}

func (APIVersionSpecOpenApiSpecOperationSetsArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APIVersionSpecOpenApiSpecOperationSets)(nil)).Elem()
}

func (i APIVersionSpecOpenApiSpecOperationSetsArgs) ToAPIVersionSpecOpenApiSpecOperationSetsOutput() APIVersionSpecOpenApiSpecOperationSetsOutput {
	return i.ToAPIVersionSpecOpenApiSpecOperationSetsOutputWithContext(context.Background())
}

func (i APIVersionSpecOpenApiSpecOperationSetsArgs) ToAPIVersionSpecOpenApiSpecOperationSetsOutputWithContext(ctx context.Context) APIVersionSpecOpenApiSpecOperationSetsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIVersionSpecOpenApiSpecOperationSetsOutput)
}

func (i APIVersionSpecOpenApiSpecOperationSetsArgs) ToOutput(ctx context.Context) pulumix.Output[APIVersionSpecOpenApiSpecOperationSets] {
	return pulumix.Output[APIVersionSpecOpenApiSpecOperationSets]{
		OutputState: i.ToAPIVersionSpecOpenApiSpecOperationSetsOutputWithContext(ctx).OutputState,
	}
}

// APIVersionSpecOpenApiSpecOperationSetsArrayInput is an input type that accepts APIVersionSpecOpenApiSpecOperationSetsArray and APIVersionSpecOpenApiSpecOperationSetsArrayOutput values.
// You can construct a concrete instance of `APIVersionSpecOpenApiSpecOperationSetsArrayInput` via:
//
//	APIVersionSpecOpenApiSpecOperationSetsArray{ APIVersionSpecOpenApiSpecOperationSetsArgs{...} }
type APIVersionSpecOpenApiSpecOperationSetsArrayInput interface {
	pulumi.Input

	ToAPIVersionSpecOpenApiSpecOperationSetsArrayOutput() APIVersionSpecOpenApiSpecOperationSetsArrayOutput
	ToAPIVersionSpecOpenApiSpecOperationSetsArrayOutputWithContext(context.Context) APIVersionSpecOpenApiSpecOperationSetsArrayOutput
}

type APIVersionSpecOpenApiSpecOperationSetsArray []APIVersionSpecOpenApiSpecOperationSetsInput

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

func (i APIVersionSpecOpenApiSpecOperationSetsArray) ToAPIVersionSpecOpenApiSpecOperationSetsArrayOutput() APIVersionSpecOpenApiSpecOperationSetsArrayOutput {
	return i.ToAPIVersionSpecOpenApiSpecOperationSetsArrayOutputWithContext(context.Background())
}

func (i APIVersionSpecOpenApiSpecOperationSetsArray) ToAPIVersionSpecOpenApiSpecOperationSetsArrayOutputWithContext(ctx context.Context) APIVersionSpecOpenApiSpecOperationSetsArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIVersionSpecOpenApiSpecOperationSetsArrayOutput)
}

func (i APIVersionSpecOpenApiSpecOperationSetsArray) ToOutput(ctx context.Context) pulumix.Output[[]APIVersionSpecOpenApiSpecOperationSets] {
	return pulumix.Output[[]APIVersionSpecOpenApiSpecOperationSets]{
		OutputState: i.ToAPIVersionSpecOpenApiSpecOperationSetsArrayOutputWithContext(ctx).OutputState,
	}
}

// OperationSet gives a name to a set of matching OpenAPI operations.
// This set of operations can then be referenced for granular filtering in APIAccesses.
type APIVersionSpecOpenApiSpecOperationSetsOutput struct{ *pulumi.OutputState }

func (APIVersionSpecOpenApiSpecOperationSetsOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APIVersionSpecOpenApiSpecOperationSets)(nil)).Elem()
}

func (o APIVersionSpecOpenApiSpecOperationSetsOutput) ToAPIVersionSpecOpenApiSpecOperationSetsOutput() APIVersionSpecOpenApiSpecOperationSetsOutput {
	return o
}

func (o APIVersionSpecOpenApiSpecOperationSetsOutput) ToAPIVersionSpecOpenApiSpecOperationSetsOutputWithContext(ctx context.Context) APIVersionSpecOpenApiSpecOperationSetsOutput {
	return o
}

func (o APIVersionSpecOpenApiSpecOperationSetsOutput) ToOutput(ctx context.Context) pulumix.Output[APIVersionSpecOpenApiSpecOperationSets] {
	return pulumix.Output[APIVersionSpecOpenApiSpecOperationSets]{
		OutputState: o.OutputState,
	}
}

// Matchers defines a list of alternative rules for matching OpenAPI operations.
func (o APIVersionSpecOpenApiSpecOperationSetsOutput) Matchers() APIVersionSpecOpenApiSpecOperationSetsMatchersArrayOutput {
	return o.ApplyT(func(v APIVersionSpecOpenApiSpecOperationSets) []APIVersionSpecOpenApiSpecOperationSetsMatchers {
		return v.Matchers
	}).(APIVersionSpecOpenApiSpecOperationSetsMatchersArrayOutput)
}

// Name is the name of the OperationSet to reference in APIAccesses.
func (o APIVersionSpecOpenApiSpecOperationSetsOutput) Name() pulumi.StringOutput {
	return o.ApplyT(func(v APIVersionSpecOpenApiSpecOperationSets) string { return v.Name }).(pulumi.StringOutput)
}

type APIVersionSpecOpenApiSpecOperationSetsArrayOutput struct{ *pulumi.OutputState }

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

func (o APIVersionSpecOpenApiSpecOperationSetsArrayOutput) ToAPIVersionSpecOpenApiSpecOperationSetsArrayOutput() APIVersionSpecOpenApiSpecOperationSetsArrayOutput {
	return o
}

func (o APIVersionSpecOpenApiSpecOperationSetsArrayOutput) ToAPIVersionSpecOpenApiSpecOperationSetsArrayOutputWithContext(ctx context.Context) APIVersionSpecOpenApiSpecOperationSetsArrayOutput {
	return o
}

func (o APIVersionSpecOpenApiSpecOperationSetsArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]APIVersionSpecOpenApiSpecOperationSets] {
	return pulumix.Output[[]APIVersionSpecOpenApiSpecOperationSets]{
		OutputState: o.OutputState,
	}
}

func (o APIVersionSpecOpenApiSpecOperationSetsArrayOutput) Index(i pulumi.IntInput) APIVersionSpecOpenApiSpecOperationSetsOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) APIVersionSpecOpenApiSpecOperationSets {
		return vs[0].([]APIVersionSpecOpenApiSpecOperationSets)[vs[1].(int)]
	}).(APIVersionSpecOpenApiSpecOperationSetsOutput)
}

// OperationMatcher defines criteria for matching an OpenAPI operation.
type APIVersionSpecOpenApiSpecOperationSetsMatchers struct {
	// Methods specifies the HTTP methods to be included for selection.
	Methods []string `pulumi:"methods"`
	// Path specifies the exact path of the operations to select.
	Path *string `pulumi:"path"`
	// PathPrefix specifies the path prefix of the operations to select.
	PathPrefix *string `pulumi:"pathPrefix"`
	// PathRegex specifies a regular expression pattern for matching operations based on their paths.
	PathRegex *string `pulumi:"pathRegex"`
}

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

	ToAPIVersionSpecOpenApiSpecOperationSetsMatchersOutput() APIVersionSpecOpenApiSpecOperationSetsMatchersOutput
	ToAPIVersionSpecOpenApiSpecOperationSetsMatchersOutputWithContext(context.Context) APIVersionSpecOpenApiSpecOperationSetsMatchersOutput
}

// OperationMatcher defines criteria for matching an OpenAPI operation.
type APIVersionSpecOpenApiSpecOperationSetsMatchersArgs struct {
	// Methods specifies the HTTP methods to be included for selection.
	Methods pulumi.StringArrayInput `pulumi:"methods"`
	// Path specifies the exact path of the operations to select.
	Path pulumi.StringPtrInput `pulumi:"path"`
	// PathPrefix specifies the path prefix of the operations to select.
	PathPrefix pulumi.StringPtrInput `pulumi:"pathPrefix"`
	// PathRegex specifies a regular expression pattern for matching operations based on their paths.
	PathRegex pulumi.StringPtrInput `pulumi:"pathRegex"`
}

func (APIVersionSpecOpenApiSpecOperationSetsMatchersArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APIVersionSpecOpenApiSpecOperationSetsMatchers)(nil)).Elem()
}

func (i APIVersionSpecOpenApiSpecOperationSetsMatchersArgs) ToAPIVersionSpecOpenApiSpecOperationSetsMatchersOutput() APIVersionSpecOpenApiSpecOperationSetsMatchersOutput {
	return i.ToAPIVersionSpecOpenApiSpecOperationSetsMatchersOutputWithContext(context.Background())
}

func (i APIVersionSpecOpenApiSpecOperationSetsMatchersArgs) ToAPIVersionSpecOpenApiSpecOperationSetsMatchersOutputWithContext(ctx context.Context) APIVersionSpecOpenApiSpecOperationSetsMatchersOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIVersionSpecOpenApiSpecOperationSetsMatchersOutput)
}

func (i APIVersionSpecOpenApiSpecOperationSetsMatchersArgs) ToOutput(ctx context.Context) pulumix.Output[APIVersionSpecOpenApiSpecOperationSetsMatchers] {
	return pulumix.Output[APIVersionSpecOpenApiSpecOperationSetsMatchers]{
		OutputState: i.ToAPIVersionSpecOpenApiSpecOperationSetsMatchersOutputWithContext(ctx).OutputState,
	}
}

// APIVersionSpecOpenApiSpecOperationSetsMatchersArrayInput is an input type that accepts APIVersionSpecOpenApiSpecOperationSetsMatchersArray and APIVersionSpecOpenApiSpecOperationSetsMatchersArrayOutput values.
// You can construct a concrete instance of `APIVersionSpecOpenApiSpecOperationSetsMatchersArrayInput` via:
//
//	APIVersionSpecOpenApiSpecOperationSetsMatchersArray{ APIVersionSpecOpenApiSpecOperationSetsMatchersArgs{...} }
type APIVersionSpecOpenApiSpecOperationSetsMatchersArrayInput interface {
	pulumi.Input

	ToAPIVersionSpecOpenApiSpecOperationSetsMatchersArrayOutput() APIVersionSpecOpenApiSpecOperationSetsMatchersArrayOutput
	ToAPIVersionSpecOpenApiSpecOperationSetsMatchersArrayOutputWithContext(context.Context) APIVersionSpecOpenApiSpecOperationSetsMatchersArrayOutput
}

type APIVersionSpecOpenApiSpecOperationSetsMatchersArray []APIVersionSpecOpenApiSpecOperationSetsMatchersInput

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

func (i APIVersionSpecOpenApiSpecOperationSetsMatchersArray) ToAPIVersionSpecOpenApiSpecOperationSetsMatchersArrayOutput() APIVersionSpecOpenApiSpecOperationSetsMatchersArrayOutput {
	return i.ToAPIVersionSpecOpenApiSpecOperationSetsMatchersArrayOutputWithContext(context.Background())
}

func (i APIVersionSpecOpenApiSpecOperationSetsMatchersArray) ToAPIVersionSpecOpenApiSpecOperationSetsMatchersArrayOutputWithContext(ctx context.Context) APIVersionSpecOpenApiSpecOperationSetsMatchersArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIVersionSpecOpenApiSpecOperationSetsMatchersArrayOutput)
}

func (i APIVersionSpecOpenApiSpecOperationSetsMatchersArray) ToOutput(ctx context.Context) pulumix.Output[[]APIVersionSpecOpenApiSpecOperationSetsMatchers] {
	return pulumix.Output[[]APIVersionSpecOpenApiSpecOperationSetsMatchers]{
		OutputState: i.ToAPIVersionSpecOpenApiSpecOperationSetsMatchersArrayOutputWithContext(ctx).OutputState,
	}
}

// OperationMatcher defines criteria for matching an OpenAPI operation.
type APIVersionSpecOpenApiSpecOperationSetsMatchersOutput struct{ *pulumi.OutputState }

func (APIVersionSpecOpenApiSpecOperationSetsMatchersOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APIVersionSpecOpenApiSpecOperationSetsMatchers)(nil)).Elem()
}

func (o APIVersionSpecOpenApiSpecOperationSetsMatchersOutput) ToAPIVersionSpecOpenApiSpecOperationSetsMatchersOutput() APIVersionSpecOpenApiSpecOperationSetsMatchersOutput {
	return o
}

func (o APIVersionSpecOpenApiSpecOperationSetsMatchersOutput) ToAPIVersionSpecOpenApiSpecOperationSetsMatchersOutputWithContext(ctx context.Context) APIVersionSpecOpenApiSpecOperationSetsMatchersOutput {
	return o
}

func (o APIVersionSpecOpenApiSpecOperationSetsMatchersOutput) ToOutput(ctx context.Context) pulumix.Output[APIVersionSpecOpenApiSpecOperationSetsMatchers] {
	return pulumix.Output[APIVersionSpecOpenApiSpecOperationSetsMatchers]{
		OutputState: o.OutputState,
	}
}

// Methods specifies the HTTP methods to be included for selection.
func (o APIVersionSpecOpenApiSpecOperationSetsMatchersOutput) Methods() pulumi.StringArrayOutput {
	return o.ApplyT(func(v APIVersionSpecOpenApiSpecOperationSetsMatchers) []string { return v.Methods }).(pulumi.StringArrayOutput)
}

// Path specifies the exact path of the operations to select.
func (o APIVersionSpecOpenApiSpecOperationSetsMatchersOutput) Path() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIVersionSpecOpenApiSpecOperationSetsMatchers) *string { return v.Path }).(pulumi.StringPtrOutput)
}

// PathPrefix specifies the path prefix of the operations to select.
func (o APIVersionSpecOpenApiSpecOperationSetsMatchersOutput) PathPrefix() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIVersionSpecOpenApiSpecOperationSetsMatchers) *string { return v.PathPrefix }).(pulumi.StringPtrOutput)
}

// PathRegex specifies a regular expression pattern for matching operations based on their paths.
func (o APIVersionSpecOpenApiSpecOperationSetsMatchersOutput) PathRegex() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIVersionSpecOpenApiSpecOperationSetsMatchers) *string { return v.PathRegex }).(pulumi.StringPtrOutput)
}

type APIVersionSpecOpenApiSpecOperationSetsMatchersArrayOutput struct{ *pulumi.OutputState }

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

func (o APIVersionSpecOpenApiSpecOperationSetsMatchersArrayOutput) ToAPIVersionSpecOpenApiSpecOperationSetsMatchersArrayOutput() APIVersionSpecOpenApiSpecOperationSetsMatchersArrayOutput {
	return o
}

func (o APIVersionSpecOpenApiSpecOperationSetsMatchersArrayOutput) ToAPIVersionSpecOpenApiSpecOperationSetsMatchersArrayOutputWithContext(ctx context.Context) APIVersionSpecOpenApiSpecOperationSetsMatchersArrayOutput {
	return o
}

func (o APIVersionSpecOpenApiSpecOperationSetsMatchersArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]APIVersionSpecOpenApiSpecOperationSetsMatchers] {
	return pulumix.Output[[]APIVersionSpecOpenApiSpecOperationSetsMatchers]{
		OutputState: o.OutputState,
	}
}

func (o APIVersionSpecOpenApiSpecOperationSetsMatchersArrayOutput) Index(i pulumi.IntInput) APIVersionSpecOpenApiSpecOperationSetsMatchersOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) APIVersionSpecOpenApiSpecOperationSetsMatchers {
		return vs[0].([]APIVersionSpecOpenApiSpecOperationSetsMatchers)[vs[1].(int)]
	}).(APIVersionSpecOpenApiSpecOperationSetsMatchersOutput)
}

// Override holds data used to override OpenAPI specification.
type APIVersionSpecOpenApiSpecOverride struct {
	Servers []APIVersionSpecOpenApiSpecOverrideServers `pulumi:"servers"`
}

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

	ToAPIVersionSpecOpenApiSpecOverrideOutput() APIVersionSpecOpenApiSpecOverrideOutput
	ToAPIVersionSpecOpenApiSpecOverrideOutputWithContext(context.Context) APIVersionSpecOpenApiSpecOverrideOutput
}

// Override holds data used to override OpenAPI specification.
type APIVersionSpecOpenApiSpecOverrideArgs struct {
	Servers APIVersionSpecOpenApiSpecOverrideServersArrayInput `pulumi:"servers"`
}

func (APIVersionSpecOpenApiSpecOverrideArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APIVersionSpecOpenApiSpecOverride)(nil)).Elem()
}

func (i APIVersionSpecOpenApiSpecOverrideArgs) ToAPIVersionSpecOpenApiSpecOverrideOutput() APIVersionSpecOpenApiSpecOverrideOutput {
	return i.ToAPIVersionSpecOpenApiSpecOverrideOutputWithContext(context.Background())
}

func (i APIVersionSpecOpenApiSpecOverrideArgs) ToAPIVersionSpecOpenApiSpecOverrideOutputWithContext(ctx context.Context) APIVersionSpecOpenApiSpecOverrideOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIVersionSpecOpenApiSpecOverrideOutput)
}

func (i APIVersionSpecOpenApiSpecOverrideArgs) ToOutput(ctx context.Context) pulumix.Output[APIVersionSpecOpenApiSpecOverride] {
	return pulumix.Output[APIVersionSpecOpenApiSpecOverride]{
		OutputState: i.ToAPIVersionSpecOpenApiSpecOverrideOutputWithContext(ctx).OutputState,
	}
}

func (i APIVersionSpecOpenApiSpecOverrideArgs) ToAPIVersionSpecOpenApiSpecOverridePtrOutput() APIVersionSpecOpenApiSpecOverridePtrOutput {
	return i.ToAPIVersionSpecOpenApiSpecOverridePtrOutputWithContext(context.Background())
}

func (i APIVersionSpecOpenApiSpecOverrideArgs) ToAPIVersionSpecOpenApiSpecOverridePtrOutputWithContext(ctx context.Context) APIVersionSpecOpenApiSpecOverridePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIVersionSpecOpenApiSpecOverrideOutput).ToAPIVersionSpecOpenApiSpecOverridePtrOutputWithContext(ctx)
}

// APIVersionSpecOpenApiSpecOverridePtrInput is an input type that accepts APIVersionSpecOpenApiSpecOverrideArgs, APIVersionSpecOpenApiSpecOverridePtr and APIVersionSpecOpenApiSpecOverridePtrOutput values.
// You can construct a concrete instance of `APIVersionSpecOpenApiSpecOverridePtrInput` via:
//
//	        APIVersionSpecOpenApiSpecOverrideArgs{...}
//
//	or:
//
//	        nil
type APIVersionSpecOpenApiSpecOverridePtrInput interface {
	pulumi.Input

	ToAPIVersionSpecOpenApiSpecOverridePtrOutput() APIVersionSpecOpenApiSpecOverridePtrOutput
	ToAPIVersionSpecOpenApiSpecOverridePtrOutputWithContext(context.Context) APIVersionSpecOpenApiSpecOverridePtrOutput
}

type apiversionSpecOpenApiSpecOverridePtrType APIVersionSpecOpenApiSpecOverrideArgs

func APIVersionSpecOpenApiSpecOverridePtr(v *APIVersionSpecOpenApiSpecOverrideArgs) APIVersionSpecOpenApiSpecOverridePtrInput {
	return (*apiversionSpecOpenApiSpecOverridePtrType)(v)
}

func (*apiversionSpecOpenApiSpecOverridePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**APIVersionSpecOpenApiSpecOverride)(nil)).Elem()
}

func (i *apiversionSpecOpenApiSpecOverridePtrType) ToAPIVersionSpecOpenApiSpecOverridePtrOutput() APIVersionSpecOpenApiSpecOverridePtrOutput {
	return i.ToAPIVersionSpecOpenApiSpecOverridePtrOutputWithContext(context.Background())
}

func (i *apiversionSpecOpenApiSpecOverridePtrType) ToAPIVersionSpecOpenApiSpecOverridePtrOutputWithContext(ctx context.Context) APIVersionSpecOpenApiSpecOverridePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIVersionSpecOpenApiSpecOverridePtrOutput)
}

func (i *apiversionSpecOpenApiSpecOverridePtrType) ToOutput(ctx context.Context) pulumix.Output[*APIVersionSpecOpenApiSpecOverride] {
	return pulumix.Output[*APIVersionSpecOpenApiSpecOverride]{
		OutputState: i.ToAPIVersionSpecOpenApiSpecOverridePtrOutputWithContext(ctx).OutputState,
	}
}

// Override holds data used to override OpenAPI specification.
type APIVersionSpecOpenApiSpecOverrideOutput struct{ *pulumi.OutputState }

func (APIVersionSpecOpenApiSpecOverrideOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APIVersionSpecOpenApiSpecOverride)(nil)).Elem()
}

func (o APIVersionSpecOpenApiSpecOverrideOutput) ToAPIVersionSpecOpenApiSpecOverrideOutput() APIVersionSpecOpenApiSpecOverrideOutput {
	return o
}

func (o APIVersionSpecOpenApiSpecOverrideOutput) ToAPIVersionSpecOpenApiSpecOverrideOutputWithContext(ctx context.Context) APIVersionSpecOpenApiSpecOverrideOutput {
	return o
}

func (o APIVersionSpecOpenApiSpecOverrideOutput) ToAPIVersionSpecOpenApiSpecOverridePtrOutput() APIVersionSpecOpenApiSpecOverridePtrOutput {
	return o.ToAPIVersionSpecOpenApiSpecOverridePtrOutputWithContext(context.Background())
}

func (o APIVersionSpecOpenApiSpecOverrideOutput) ToAPIVersionSpecOpenApiSpecOverridePtrOutputWithContext(ctx context.Context) APIVersionSpecOpenApiSpecOverridePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v APIVersionSpecOpenApiSpecOverride) *APIVersionSpecOpenApiSpecOverride {
		return &v
	}).(APIVersionSpecOpenApiSpecOverridePtrOutput)
}

func (o APIVersionSpecOpenApiSpecOverrideOutput) ToOutput(ctx context.Context) pulumix.Output[APIVersionSpecOpenApiSpecOverride] {
	return pulumix.Output[APIVersionSpecOpenApiSpecOverride]{
		OutputState: o.OutputState,
	}
}

func (o APIVersionSpecOpenApiSpecOverrideOutput) Servers() APIVersionSpecOpenApiSpecOverrideServersArrayOutput {
	return o.ApplyT(func(v APIVersionSpecOpenApiSpecOverride) []APIVersionSpecOpenApiSpecOverrideServers { return v.Servers }).(APIVersionSpecOpenApiSpecOverrideServersArrayOutput)
}

type APIVersionSpecOpenApiSpecOverridePtrOutput struct{ *pulumi.OutputState }

func (APIVersionSpecOpenApiSpecOverridePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**APIVersionSpecOpenApiSpecOverride)(nil)).Elem()
}

func (o APIVersionSpecOpenApiSpecOverridePtrOutput) ToAPIVersionSpecOpenApiSpecOverridePtrOutput() APIVersionSpecOpenApiSpecOverridePtrOutput {
	return o
}

func (o APIVersionSpecOpenApiSpecOverridePtrOutput) ToAPIVersionSpecOpenApiSpecOverridePtrOutputWithContext(ctx context.Context) APIVersionSpecOpenApiSpecOverridePtrOutput {
	return o
}

func (o APIVersionSpecOpenApiSpecOverridePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*APIVersionSpecOpenApiSpecOverride] {
	return pulumix.Output[*APIVersionSpecOpenApiSpecOverride]{
		OutputState: o.OutputState,
	}
}

func (o APIVersionSpecOpenApiSpecOverridePtrOutput) Elem() APIVersionSpecOpenApiSpecOverrideOutput {
	return o.ApplyT(func(v *APIVersionSpecOpenApiSpecOverride) APIVersionSpecOpenApiSpecOverride {
		if v != nil {
			return *v
		}
		var ret APIVersionSpecOpenApiSpecOverride
		return ret
	}).(APIVersionSpecOpenApiSpecOverrideOutput)
}

func (o APIVersionSpecOpenApiSpecOverridePtrOutput) Servers() APIVersionSpecOpenApiSpecOverrideServersArrayOutput {
	return o.ApplyT(func(v *APIVersionSpecOpenApiSpecOverride) []APIVersionSpecOpenApiSpecOverrideServers {
		if v == nil {
			return nil
		}
		return v.Servers
	}).(APIVersionSpecOpenApiSpecOverrideServersArrayOutput)
}

type APIVersionSpecOpenApiSpecOverrideServers struct {
	Url string `pulumi:"url"`
}

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

	ToAPIVersionSpecOpenApiSpecOverrideServersOutput() APIVersionSpecOpenApiSpecOverrideServersOutput
	ToAPIVersionSpecOpenApiSpecOverrideServersOutputWithContext(context.Context) APIVersionSpecOpenApiSpecOverrideServersOutput
}

type APIVersionSpecOpenApiSpecOverrideServersArgs struct {
	Url pulumi.StringInput `pulumi:"url"`
}

func (APIVersionSpecOpenApiSpecOverrideServersArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APIVersionSpecOpenApiSpecOverrideServers)(nil)).Elem()
}

func (i APIVersionSpecOpenApiSpecOverrideServersArgs) ToAPIVersionSpecOpenApiSpecOverrideServersOutput() APIVersionSpecOpenApiSpecOverrideServersOutput {
	return i.ToAPIVersionSpecOpenApiSpecOverrideServersOutputWithContext(context.Background())
}

func (i APIVersionSpecOpenApiSpecOverrideServersArgs) ToAPIVersionSpecOpenApiSpecOverrideServersOutputWithContext(ctx context.Context) APIVersionSpecOpenApiSpecOverrideServersOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIVersionSpecOpenApiSpecOverrideServersOutput)
}

func (i APIVersionSpecOpenApiSpecOverrideServersArgs) ToOutput(ctx context.Context) pulumix.Output[APIVersionSpecOpenApiSpecOverrideServers] {
	return pulumix.Output[APIVersionSpecOpenApiSpecOverrideServers]{
		OutputState: i.ToAPIVersionSpecOpenApiSpecOverrideServersOutputWithContext(ctx).OutputState,
	}
}

// APIVersionSpecOpenApiSpecOverrideServersArrayInput is an input type that accepts APIVersionSpecOpenApiSpecOverrideServersArray and APIVersionSpecOpenApiSpecOverrideServersArrayOutput values.
// You can construct a concrete instance of `APIVersionSpecOpenApiSpecOverrideServersArrayInput` via:
//
//	APIVersionSpecOpenApiSpecOverrideServersArray{ APIVersionSpecOpenApiSpecOverrideServersArgs{...} }
type APIVersionSpecOpenApiSpecOverrideServersArrayInput interface {
	pulumi.Input

	ToAPIVersionSpecOpenApiSpecOverrideServersArrayOutput() APIVersionSpecOpenApiSpecOverrideServersArrayOutput
	ToAPIVersionSpecOpenApiSpecOverrideServersArrayOutputWithContext(context.Context) APIVersionSpecOpenApiSpecOverrideServersArrayOutput
}

type APIVersionSpecOpenApiSpecOverrideServersArray []APIVersionSpecOpenApiSpecOverrideServersInput

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

func (i APIVersionSpecOpenApiSpecOverrideServersArray) ToAPIVersionSpecOpenApiSpecOverrideServersArrayOutput() APIVersionSpecOpenApiSpecOverrideServersArrayOutput {
	return i.ToAPIVersionSpecOpenApiSpecOverrideServersArrayOutputWithContext(context.Background())
}

func (i APIVersionSpecOpenApiSpecOverrideServersArray) ToAPIVersionSpecOpenApiSpecOverrideServersArrayOutputWithContext(ctx context.Context) APIVersionSpecOpenApiSpecOverrideServersArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIVersionSpecOpenApiSpecOverrideServersArrayOutput)
}

func (i APIVersionSpecOpenApiSpecOverrideServersArray) ToOutput(ctx context.Context) pulumix.Output[[]APIVersionSpecOpenApiSpecOverrideServers] {
	return pulumix.Output[[]APIVersionSpecOpenApiSpecOverrideServers]{
		OutputState: i.ToAPIVersionSpecOpenApiSpecOverrideServersArrayOutputWithContext(ctx).OutputState,
	}
}

type APIVersionSpecOpenApiSpecOverrideServersOutput struct{ *pulumi.OutputState }

func (APIVersionSpecOpenApiSpecOverrideServersOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APIVersionSpecOpenApiSpecOverrideServers)(nil)).Elem()
}

func (o APIVersionSpecOpenApiSpecOverrideServersOutput) ToAPIVersionSpecOpenApiSpecOverrideServersOutput() APIVersionSpecOpenApiSpecOverrideServersOutput {
	return o
}

func (o APIVersionSpecOpenApiSpecOverrideServersOutput) ToAPIVersionSpecOpenApiSpecOverrideServersOutputWithContext(ctx context.Context) APIVersionSpecOpenApiSpecOverrideServersOutput {
	return o
}

func (o APIVersionSpecOpenApiSpecOverrideServersOutput) ToOutput(ctx context.Context) pulumix.Output[APIVersionSpecOpenApiSpecOverrideServers] {
	return pulumix.Output[APIVersionSpecOpenApiSpecOverrideServers]{
		OutputState: o.OutputState,
	}
}

func (o APIVersionSpecOpenApiSpecOverrideServersOutput) Url() pulumi.StringOutput {
	return o.ApplyT(func(v APIVersionSpecOpenApiSpecOverrideServers) string { return v.Url }).(pulumi.StringOutput)
}

type APIVersionSpecOpenApiSpecOverrideServersArrayOutput struct{ *pulumi.OutputState }

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

func (o APIVersionSpecOpenApiSpecOverrideServersArrayOutput) ToAPIVersionSpecOpenApiSpecOverrideServersArrayOutput() APIVersionSpecOpenApiSpecOverrideServersArrayOutput {
	return o
}

func (o APIVersionSpecOpenApiSpecOverrideServersArrayOutput) ToAPIVersionSpecOpenApiSpecOverrideServersArrayOutputWithContext(ctx context.Context) APIVersionSpecOpenApiSpecOverrideServersArrayOutput {
	return o
}

func (o APIVersionSpecOpenApiSpecOverrideServersArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]APIVersionSpecOpenApiSpecOverrideServers] {
	return pulumix.Output[[]APIVersionSpecOpenApiSpecOverrideServers]{
		OutputState: o.OutputState,
	}
}

func (o APIVersionSpecOpenApiSpecOverrideServersArrayOutput) Index(i pulumi.IntInput) APIVersionSpecOpenApiSpecOverrideServersOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) APIVersionSpecOpenApiSpecOverrideServers {
		return vs[0].([]APIVersionSpecOpenApiSpecOverrideServers)[vs[1].(int)]
	}).(APIVersionSpecOpenApiSpecOverrideServersOutput)
}

// The current status of this APIVersion.
type APIVersionStatus struct {
	// Hash is a hash representing the APIVersion.
	Hash     *string `pulumi:"hash"`
	SyncedAt *string `pulumi:"syncedAt"`
	Version  *string `pulumi:"version"`
}

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

	ToAPIVersionStatusOutput() APIVersionStatusOutput
	ToAPIVersionStatusOutputWithContext(context.Context) APIVersionStatusOutput
}

// The current status of this APIVersion.
type APIVersionStatusArgs struct {
	// Hash is a hash representing the APIVersion.
	Hash     pulumi.StringPtrInput `pulumi:"hash"`
	SyncedAt pulumi.StringPtrInput `pulumi:"syncedAt"`
	Version  pulumi.StringPtrInput `pulumi:"version"`
}

func (APIVersionStatusArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*APIVersionStatus)(nil)).Elem()
}

func (i APIVersionStatusArgs) ToAPIVersionStatusOutput() APIVersionStatusOutput {
	return i.ToAPIVersionStatusOutputWithContext(context.Background())
}

func (i APIVersionStatusArgs) ToAPIVersionStatusOutputWithContext(ctx context.Context) APIVersionStatusOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIVersionStatusOutput)
}

func (i APIVersionStatusArgs) ToOutput(ctx context.Context) pulumix.Output[APIVersionStatus] {
	return pulumix.Output[APIVersionStatus]{
		OutputState: i.ToAPIVersionStatusOutputWithContext(ctx).OutputState,
	}
}

func (i APIVersionStatusArgs) ToAPIVersionStatusPtrOutput() APIVersionStatusPtrOutput {
	return i.ToAPIVersionStatusPtrOutputWithContext(context.Background())
}

func (i APIVersionStatusArgs) ToAPIVersionStatusPtrOutputWithContext(ctx context.Context) APIVersionStatusPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIVersionStatusOutput).ToAPIVersionStatusPtrOutputWithContext(ctx)
}

// APIVersionStatusPtrInput is an input type that accepts APIVersionStatusArgs, APIVersionStatusPtr and APIVersionStatusPtrOutput values.
// You can construct a concrete instance of `APIVersionStatusPtrInput` via:
//
//	        APIVersionStatusArgs{...}
//
//	or:
//
//	        nil
type APIVersionStatusPtrInput interface {
	pulumi.Input

	ToAPIVersionStatusPtrOutput() APIVersionStatusPtrOutput
	ToAPIVersionStatusPtrOutputWithContext(context.Context) APIVersionStatusPtrOutput
}

type apiversionStatusPtrType APIVersionStatusArgs

func APIVersionStatusPtr(v *APIVersionStatusArgs) APIVersionStatusPtrInput {
	return (*apiversionStatusPtrType)(v)
}

func (*apiversionStatusPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**APIVersionStatus)(nil)).Elem()
}

func (i *apiversionStatusPtrType) ToAPIVersionStatusPtrOutput() APIVersionStatusPtrOutput {
	return i.ToAPIVersionStatusPtrOutputWithContext(context.Background())
}

func (i *apiversionStatusPtrType) ToAPIVersionStatusPtrOutputWithContext(ctx context.Context) APIVersionStatusPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(APIVersionStatusPtrOutput)
}

func (i *apiversionStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*APIVersionStatus] {
	return pulumix.Output[*APIVersionStatus]{
		OutputState: i.ToAPIVersionStatusPtrOutputWithContext(ctx).OutputState,
	}
}

// The current status of this APIVersion.
type APIVersionStatusOutput struct{ *pulumi.OutputState }

func (APIVersionStatusOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*APIVersionStatus)(nil)).Elem()
}

func (o APIVersionStatusOutput) ToAPIVersionStatusOutput() APIVersionStatusOutput {
	return o
}

func (o APIVersionStatusOutput) ToAPIVersionStatusOutputWithContext(ctx context.Context) APIVersionStatusOutput {
	return o
}

func (o APIVersionStatusOutput) ToAPIVersionStatusPtrOutput() APIVersionStatusPtrOutput {
	return o.ToAPIVersionStatusPtrOutputWithContext(context.Background())
}

func (o APIVersionStatusOutput) ToAPIVersionStatusPtrOutputWithContext(ctx context.Context) APIVersionStatusPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v APIVersionStatus) *APIVersionStatus {
		return &v
	}).(APIVersionStatusPtrOutput)
}

func (o APIVersionStatusOutput) ToOutput(ctx context.Context) pulumix.Output[APIVersionStatus] {
	return pulumix.Output[APIVersionStatus]{
		OutputState: o.OutputState,
	}
}

// Hash is a hash representing the APIVersion.
func (o APIVersionStatusOutput) Hash() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIVersionStatus) *string { return v.Hash }).(pulumi.StringPtrOutput)
}

func (o APIVersionStatusOutput) SyncedAt() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIVersionStatus) *string { return v.SyncedAt }).(pulumi.StringPtrOutput)
}

func (o APIVersionStatusOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v APIVersionStatus) *string { return v.Version }).(pulumi.StringPtrOutput)
}

type APIVersionStatusPtrOutput struct{ *pulumi.OutputState }

func (APIVersionStatusPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**APIVersionStatus)(nil)).Elem()
}

func (o APIVersionStatusPtrOutput) ToAPIVersionStatusPtrOutput() APIVersionStatusPtrOutput {
	return o
}

func (o APIVersionStatusPtrOutput) ToAPIVersionStatusPtrOutputWithContext(ctx context.Context) APIVersionStatusPtrOutput {
	return o
}

func (o APIVersionStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*APIVersionStatus] {
	return pulumix.Output[*APIVersionStatus]{
		OutputState: o.OutputState,
	}
}

func (o APIVersionStatusPtrOutput) Elem() APIVersionStatusOutput {
	return o.ApplyT(func(v *APIVersionStatus) APIVersionStatus {
		if v != nil {
			return *v
		}
		var ret APIVersionStatus
		return ret
	}).(APIVersionStatusOutput)
}

// Hash is a hash representing the APIVersion.
func (o APIVersionStatusPtrOutput) Hash() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIVersionStatus) *string {
		if v == nil {
			return nil
		}
		return v.Hash
	}).(pulumi.StringPtrOutput)
}

func (o APIVersionStatusPtrOutput) SyncedAt() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIVersionStatus) *string {
		if v == nil {
			return nil
		}
		return v.SyncedAt
	}).(pulumi.StringPtrOutput)
}

func (o APIVersionStatusPtrOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *APIVersionStatus) *string {
		if v == nil {
			return nil
		}
		return v.Version
	}).(pulumi.StringPtrOutput)
}

// AccessControlPolicy defines an access control policy.
type AccessControlPolicyType struct {
	ApiVersion *string        `pulumi:"apiVersion"`
	Kind       *string        `pulumi:"kind"`
	Metadata   *v1.ObjectMeta `pulumi:"metadata"`
	// AccessControlPolicySpec configures an access control policy.
	Spec *AccessControlPolicySpec `pulumi:"spec"`
	// The current status of this access control policy.
	Status *AccessControlPolicyStatus `pulumi:"status"`
}

// Defaults sets the appropriate defaults for AccessControlPolicyType
func (val *AccessControlPolicyType) Defaults() *AccessControlPolicyType {
	if val == nil {
		return nil
	}
	tmp := *val
	tmp.Spec = tmp.Spec.Defaults()

	return &tmp
}

type AccessControlPolicyMetadata struct {
}

// AccessControlPolicySpec configures an access control policy.
type AccessControlPolicySpec struct {
	// AccessControlPolicyAPIKey configure an APIKey control policy.
	ApiKey *AccessControlPolicySpecApiKey `pulumi:"apiKey"`
	// AccessControlPolicyBasicAuth holds the HTTP basic authentication configuration.
	BasicAuth *AccessControlPolicySpecBasicAuth `pulumi:"basicAuth"`
	// AccessControlPolicyJWT configures a JWT access control policy.
	Jwt *AccessControlPolicySpecJwt `pulumi:"jwt"`
	// AccessControlOAuthIntro configures an OAuth 2.0 Token Introspection access control policy.
	OAuthIntro *AccessControlPolicySpecOAuthIntro `pulumi:"oAuthIntro"`
	// AccessControlPolicyOIDC holds the OIDC authentication configuration.
	Oidc *AccessControlPolicySpecOidc `pulumi:"oidc"`
	// AccessControlPolicyOIDCGoogle holds the Google OIDC authentication configuration.
	OidcGoogle *AccessControlPolicySpecOidcGoogle `pulumi:"oidcGoogle"`
}

// Defaults sets the appropriate defaults for AccessControlPolicySpec
func (val *AccessControlPolicySpec) Defaults() *AccessControlPolicySpec {
	if val == nil {
		return nil
	}
	tmp := *val
	tmp.OAuthIntro = tmp.OAuthIntro.Defaults()

	return &tmp
}

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

	ToAccessControlPolicySpecOutput() AccessControlPolicySpecOutput
	ToAccessControlPolicySpecOutputWithContext(context.Context) AccessControlPolicySpecOutput
}

// AccessControlPolicySpec configures an access control policy.
type AccessControlPolicySpecArgs struct {
	// AccessControlPolicyAPIKey configure an APIKey control policy.
	ApiKey AccessControlPolicySpecApiKeyPtrInput `pulumi:"apiKey"`
	// AccessControlPolicyBasicAuth holds the HTTP basic authentication configuration.
	BasicAuth AccessControlPolicySpecBasicAuthPtrInput `pulumi:"basicAuth"`
	// AccessControlPolicyJWT configures a JWT access control policy.
	Jwt AccessControlPolicySpecJwtPtrInput `pulumi:"jwt"`
	// AccessControlOAuthIntro configures an OAuth 2.0 Token Introspection access control policy.
	OAuthIntro AccessControlPolicySpecOAuthIntroPtrInput `pulumi:"oAuthIntro"`
	// AccessControlPolicyOIDC holds the OIDC authentication configuration.
	Oidc AccessControlPolicySpecOidcPtrInput `pulumi:"oidc"`
	// AccessControlPolicyOIDCGoogle holds the Google OIDC authentication configuration.
	OidcGoogle AccessControlPolicySpecOidcGooglePtrInput `pulumi:"oidcGoogle"`
}

// Defaults sets the appropriate defaults for AccessControlPolicySpecArgs
func (val *AccessControlPolicySpecArgs) Defaults() *AccessControlPolicySpecArgs {
	if val == nil {
		return nil
	}
	tmp := *val

	return &tmp
}
func (AccessControlPolicySpecArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpec)(nil)).Elem()
}

func (i AccessControlPolicySpecArgs) ToAccessControlPolicySpecOutput() AccessControlPolicySpecOutput {
	return i.ToAccessControlPolicySpecOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecArgs) ToAccessControlPolicySpecOutputWithContext(ctx context.Context) AccessControlPolicySpecOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOutput)
}

func (i AccessControlPolicySpecArgs) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpec] {
	return pulumix.Output[AccessControlPolicySpec]{
		OutputState: i.ToAccessControlPolicySpecOutputWithContext(ctx).OutputState,
	}
}

func (i AccessControlPolicySpecArgs) ToAccessControlPolicySpecPtrOutput() AccessControlPolicySpecPtrOutput {
	return i.ToAccessControlPolicySpecPtrOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecArgs) ToAccessControlPolicySpecPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOutput).ToAccessControlPolicySpecPtrOutputWithContext(ctx)
}

// AccessControlPolicySpecPtrInput is an input type that accepts AccessControlPolicySpecArgs, AccessControlPolicySpecPtr and AccessControlPolicySpecPtrOutput values.
// You can construct a concrete instance of `AccessControlPolicySpecPtrInput` via:
//
//	        AccessControlPolicySpecArgs{...}
//
//	or:
//
//	        nil
type AccessControlPolicySpecPtrInput interface {
	pulumi.Input

	ToAccessControlPolicySpecPtrOutput() AccessControlPolicySpecPtrOutput
	ToAccessControlPolicySpecPtrOutputWithContext(context.Context) AccessControlPolicySpecPtrOutput
}

type accessControlPolicySpecPtrType AccessControlPolicySpecArgs

func AccessControlPolicySpecPtr(v *AccessControlPolicySpecArgs) AccessControlPolicySpecPtrInput {
	return (*accessControlPolicySpecPtrType)(v)
}

func (*accessControlPolicySpecPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpec)(nil)).Elem()
}

func (i *accessControlPolicySpecPtrType) ToAccessControlPolicySpecPtrOutput() AccessControlPolicySpecPtrOutput {
	return i.ToAccessControlPolicySpecPtrOutputWithContext(context.Background())
}

func (i *accessControlPolicySpecPtrType) ToAccessControlPolicySpecPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecPtrOutput)
}

func (i *accessControlPolicySpecPtrType) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpec] {
	return pulumix.Output[*AccessControlPolicySpec]{
		OutputState: i.ToAccessControlPolicySpecPtrOutputWithContext(ctx).OutputState,
	}
}

// AccessControlPolicySpec configures an access control policy.
type AccessControlPolicySpecOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpec)(nil)).Elem()
}

func (o AccessControlPolicySpecOutput) ToAccessControlPolicySpecOutput() AccessControlPolicySpecOutput {
	return o
}

func (o AccessControlPolicySpecOutput) ToAccessControlPolicySpecOutputWithContext(ctx context.Context) AccessControlPolicySpecOutput {
	return o
}

func (o AccessControlPolicySpecOutput) ToAccessControlPolicySpecPtrOutput() AccessControlPolicySpecPtrOutput {
	return o.ToAccessControlPolicySpecPtrOutputWithContext(context.Background())
}

func (o AccessControlPolicySpecOutput) ToAccessControlPolicySpecPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v AccessControlPolicySpec) *AccessControlPolicySpec {
		return &v
	}).(AccessControlPolicySpecPtrOutput)
}

func (o AccessControlPolicySpecOutput) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpec] {
	return pulumix.Output[AccessControlPolicySpec]{
		OutputState: o.OutputState,
	}
}

// AccessControlPolicyAPIKey configure an APIKey control policy.
func (o AccessControlPolicySpecOutput) ApiKey() AccessControlPolicySpecApiKeyPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpec) *AccessControlPolicySpecApiKey { return v.ApiKey }).(AccessControlPolicySpecApiKeyPtrOutput)
}

// AccessControlPolicyBasicAuth holds the HTTP basic authentication configuration.
func (o AccessControlPolicySpecOutput) BasicAuth() AccessControlPolicySpecBasicAuthPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpec) *AccessControlPolicySpecBasicAuth { return v.BasicAuth }).(AccessControlPolicySpecBasicAuthPtrOutput)
}

// AccessControlPolicyJWT configures a JWT access control policy.
func (o AccessControlPolicySpecOutput) Jwt() AccessControlPolicySpecJwtPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpec) *AccessControlPolicySpecJwt { return v.Jwt }).(AccessControlPolicySpecJwtPtrOutput)
}

// AccessControlOAuthIntro configures an OAuth 2.0 Token Introspection access control policy.
func (o AccessControlPolicySpecOutput) OAuthIntro() AccessControlPolicySpecOAuthIntroPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpec) *AccessControlPolicySpecOAuthIntro { return v.OAuthIntro }).(AccessControlPolicySpecOAuthIntroPtrOutput)
}

// AccessControlPolicyOIDC holds the OIDC authentication configuration.
func (o AccessControlPolicySpecOutput) Oidc() AccessControlPolicySpecOidcPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpec) *AccessControlPolicySpecOidc { return v.Oidc }).(AccessControlPolicySpecOidcPtrOutput)
}

// AccessControlPolicyOIDCGoogle holds the Google OIDC authentication configuration.
func (o AccessControlPolicySpecOutput) OidcGoogle() AccessControlPolicySpecOidcGooglePtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpec) *AccessControlPolicySpecOidcGoogle { return v.OidcGoogle }).(AccessControlPolicySpecOidcGooglePtrOutput)
}

type AccessControlPolicySpecPtrOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpec)(nil)).Elem()
}

func (o AccessControlPolicySpecPtrOutput) ToAccessControlPolicySpecPtrOutput() AccessControlPolicySpecPtrOutput {
	return o
}

func (o AccessControlPolicySpecPtrOutput) ToAccessControlPolicySpecPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecPtrOutput {
	return o
}

func (o AccessControlPolicySpecPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpec] {
	return pulumix.Output[*AccessControlPolicySpec]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicySpecPtrOutput) Elem() AccessControlPolicySpecOutput {
	return o.ApplyT(func(v *AccessControlPolicySpec) AccessControlPolicySpec {
		if v != nil {
			return *v
		}
		var ret AccessControlPolicySpec
		return ret
	}).(AccessControlPolicySpecOutput)
}

// AccessControlPolicyAPIKey configure an APIKey control policy.
func (o AccessControlPolicySpecPtrOutput) ApiKey() AccessControlPolicySpecApiKeyPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpec) *AccessControlPolicySpecApiKey {
		if v == nil {
			return nil
		}
		return v.ApiKey
	}).(AccessControlPolicySpecApiKeyPtrOutput)
}

// AccessControlPolicyBasicAuth holds the HTTP basic authentication configuration.
func (o AccessControlPolicySpecPtrOutput) BasicAuth() AccessControlPolicySpecBasicAuthPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpec) *AccessControlPolicySpecBasicAuth {
		if v == nil {
			return nil
		}
		return v.BasicAuth
	}).(AccessControlPolicySpecBasicAuthPtrOutput)
}

// AccessControlPolicyJWT configures a JWT access control policy.
func (o AccessControlPolicySpecPtrOutput) Jwt() AccessControlPolicySpecJwtPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpec) *AccessControlPolicySpecJwt {
		if v == nil {
			return nil
		}
		return v.Jwt
	}).(AccessControlPolicySpecJwtPtrOutput)
}

// AccessControlOAuthIntro configures an OAuth 2.0 Token Introspection access control policy.
func (o AccessControlPolicySpecPtrOutput) OAuthIntro() AccessControlPolicySpecOAuthIntroPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpec) *AccessControlPolicySpecOAuthIntro {
		if v == nil {
			return nil
		}
		return v.OAuthIntro
	}).(AccessControlPolicySpecOAuthIntroPtrOutput)
}

// AccessControlPolicyOIDC holds the OIDC authentication configuration.
func (o AccessControlPolicySpecPtrOutput) Oidc() AccessControlPolicySpecOidcPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpec) *AccessControlPolicySpecOidc {
		if v == nil {
			return nil
		}
		return v.Oidc
	}).(AccessControlPolicySpecOidcPtrOutput)
}

// AccessControlPolicyOIDCGoogle holds the Google OIDC authentication configuration.
func (o AccessControlPolicySpecPtrOutput) OidcGoogle() AccessControlPolicySpecOidcGooglePtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpec) *AccessControlPolicySpecOidcGoogle {
		if v == nil {
			return nil
		}
		return v.OidcGoogle
	}).(AccessControlPolicySpecOidcGooglePtrOutput)
}

// AccessControlPolicyAPIKey configure an APIKey control policy.
type AccessControlPolicySpecApiKey struct {
	// ForwardHeaders instructs the middleware to forward key metadata as header values upon successful authentication.
	ForwardHeaders map[string]string `pulumi:"forwardHeaders"`
	// KeySource defines how to extract API keys from requests.
	KeySource AccessControlPolicySpecApiKeyKeySource `pulumi:"keySource"`
	// Keys define the set of authorized keys to access a protected resource.
	Keys []AccessControlPolicySpecApiKeyKeys `pulumi:"keys"`
}

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

	ToAccessControlPolicySpecApiKeyOutput() AccessControlPolicySpecApiKeyOutput
	ToAccessControlPolicySpecApiKeyOutputWithContext(context.Context) AccessControlPolicySpecApiKeyOutput
}

// AccessControlPolicyAPIKey configure an APIKey control policy.
type AccessControlPolicySpecApiKeyArgs struct {
	// ForwardHeaders instructs the middleware to forward key metadata as header values upon successful authentication.
	ForwardHeaders pulumi.StringMapInput `pulumi:"forwardHeaders"`
	// KeySource defines how to extract API keys from requests.
	KeySource AccessControlPolicySpecApiKeyKeySourceInput `pulumi:"keySource"`
	// Keys define the set of authorized keys to access a protected resource.
	Keys AccessControlPolicySpecApiKeyKeysArrayInput `pulumi:"keys"`
}

func (AccessControlPolicySpecApiKeyArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecApiKey)(nil)).Elem()
}

func (i AccessControlPolicySpecApiKeyArgs) ToAccessControlPolicySpecApiKeyOutput() AccessControlPolicySpecApiKeyOutput {
	return i.ToAccessControlPolicySpecApiKeyOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecApiKeyArgs) ToAccessControlPolicySpecApiKeyOutputWithContext(ctx context.Context) AccessControlPolicySpecApiKeyOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecApiKeyOutput)
}

func (i AccessControlPolicySpecApiKeyArgs) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecApiKey] {
	return pulumix.Output[AccessControlPolicySpecApiKey]{
		OutputState: i.ToAccessControlPolicySpecApiKeyOutputWithContext(ctx).OutputState,
	}
}

func (i AccessControlPolicySpecApiKeyArgs) ToAccessControlPolicySpecApiKeyPtrOutput() AccessControlPolicySpecApiKeyPtrOutput {
	return i.ToAccessControlPolicySpecApiKeyPtrOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecApiKeyArgs) ToAccessControlPolicySpecApiKeyPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecApiKeyPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecApiKeyOutput).ToAccessControlPolicySpecApiKeyPtrOutputWithContext(ctx)
}

// AccessControlPolicySpecApiKeyPtrInput is an input type that accepts AccessControlPolicySpecApiKeyArgs, AccessControlPolicySpecApiKeyPtr and AccessControlPolicySpecApiKeyPtrOutput values.
// You can construct a concrete instance of `AccessControlPolicySpecApiKeyPtrInput` via:
//
//	        AccessControlPolicySpecApiKeyArgs{...}
//
//	or:
//
//	        nil
type AccessControlPolicySpecApiKeyPtrInput interface {
	pulumi.Input

	ToAccessControlPolicySpecApiKeyPtrOutput() AccessControlPolicySpecApiKeyPtrOutput
	ToAccessControlPolicySpecApiKeyPtrOutputWithContext(context.Context) AccessControlPolicySpecApiKeyPtrOutput
}

type accessControlPolicySpecApiKeyPtrType AccessControlPolicySpecApiKeyArgs

func AccessControlPolicySpecApiKeyPtr(v *AccessControlPolicySpecApiKeyArgs) AccessControlPolicySpecApiKeyPtrInput {
	return (*accessControlPolicySpecApiKeyPtrType)(v)
}

func (*accessControlPolicySpecApiKeyPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecApiKey)(nil)).Elem()
}

func (i *accessControlPolicySpecApiKeyPtrType) ToAccessControlPolicySpecApiKeyPtrOutput() AccessControlPolicySpecApiKeyPtrOutput {
	return i.ToAccessControlPolicySpecApiKeyPtrOutputWithContext(context.Background())
}

func (i *accessControlPolicySpecApiKeyPtrType) ToAccessControlPolicySpecApiKeyPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecApiKeyPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecApiKeyPtrOutput)
}

func (i *accessControlPolicySpecApiKeyPtrType) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecApiKey] {
	return pulumix.Output[*AccessControlPolicySpecApiKey]{
		OutputState: i.ToAccessControlPolicySpecApiKeyPtrOutputWithContext(ctx).OutputState,
	}
}

// AccessControlPolicyAPIKey configure an APIKey control policy.
type AccessControlPolicySpecApiKeyOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecApiKeyOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecApiKey)(nil)).Elem()
}

func (o AccessControlPolicySpecApiKeyOutput) ToAccessControlPolicySpecApiKeyOutput() AccessControlPolicySpecApiKeyOutput {
	return o
}

func (o AccessControlPolicySpecApiKeyOutput) ToAccessControlPolicySpecApiKeyOutputWithContext(ctx context.Context) AccessControlPolicySpecApiKeyOutput {
	return o
}

func (o AccessControlPolicySpecApiKeyOutput) ToAccessControlPolicySpecApiKeyPtrOutput() AccessControlPolicySpecApiKeyPtrOutput {
	return o.ToAccessControlPolicySpecApiKeyPtrOutputWithContext(context.Background())
}

func (o AccessControlPolicySpecApiKeyOutput) ToAccessControlPolicySpecApiKeyPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecApiKeyPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v AccessControlPolicySpecApiKey) *AccessControlPolicySpecApiKey {
		return &v
	}).(AccessControlPolicySpecApiKeyPtrOutput)
}

func (o AccessControlPolicySpecApiKeyOutput) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecApiKey] {
	return pulumix.Output[AccessControlPolicySpecApiKey]{
		OutputState: o.OutputState,
	}
}

// ForwardHeaders instructs the middleware to forward key metadata as header values upon successful authentication.
func (o AccessControlPolicySpecApiKeyOutput) ForwardHeaders() pulumi.StringMapOutput {
	return o.ApplyT(func(v AccessControlPolicySpecApiKey) map[string]string { return v.ForwardHeaders }).(pulumi.StringMapOutput)
}

// KeySource defines how to extract API keys from requests.
func (o AccessControlPolicySpecApiKeyOutput) KeySource() AccessControlPolicySpecApiKeyKeySourceOutput {
	return o.ApplyT(func(v AccessControlPolicySpecApiKey) AccessControlPolicySpecApiKeyKeySource { return v.KeySource }).(AccessControlPolicySpecApiKeyKeySourceOutput)
}

// Keys define the set of authorized keys to access a protected resource.
func (o AccessControlPolicySpecApiKeyOutput) Keys() AccessControlPolicySpecApiKeyKeysArrayOutput {
	return o.ApplyT(func(v AccessControlPolicySpecApiKey) []AccessControlPolicySpecApiKeyKeys { return v.Keys }).(AccessControlPolicySpecApiKeyKeysArrayOutput)
}

type AccessControlPolicySpecApiKeyPtrOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecApiKeyPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecApiKey)(nil)).Elem()
}

func (o AccessControlPolicySpecApiKeyPtrOutput) ToAccessControlPolicySpecApiKeyPtrOutput() AccessControlPolicySpecApiKeyPtrOutput {
	return o
}

func (o AccessControlPolicySpecApiKeyPtrOutput) ToAccessControlPolicySpecApiKeyPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecApiKeyPtrOutput {
	return o
}

func (o AccessControlPolicySpecApiKeyPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecApiKey] {
	return pulumix.Output[*AccessControlPolicySpecApiKey]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicySpecApiKeyPtrOutput) Elem() AccessControlPolicySpecApiKeyOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecApiKey) AccessControlPolicySpecApiKey {
		if v != nil {
			return *v
		}
		var ret AccessControlPolicySpecApiKey
		return ret
	}).(AccessControlPolicySpecApiKeyOutput)
}

// ForwardHeaders instructs the middleware to forward key metadata as header values upon successful authentication.
func (o AccessControlPolicySpecApiKeyPtrOutput) ForwardHeaders() pulumi.StringMapOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecApiKey) map[string]string {
		if v == nil {
			return nil
		}
		return v.ForwardHeaders
	}).(pulumi.StringMapOutput)
}

// KeySource defines how to extract API keys from requests.
func (o AccessControlPolicySpecApiKeyPtrOutput) KeySource() AccessControlPolicySpecApiKeyKeySourcePtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecApiKey) *AccessControlPolicySpecApiKeyKeySource {
		if v == nil {
			return nil
		}
		return &v.KeySource
	}).(AccessControlPolicySpecApiKeyKeySourcePtrOutput)
}

// Keys define the set of authorized keys to access a protected resource.
func (o AccessControlPolicySpecApiKeyPtrOutput) Keys() AccessControlPolicySpecApiKeyKeysArrayOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecApiKey) []AccessControlPolicySpecApiKeyKeys {
		if v == nil {
			return nil
		}
		return v.Keys
	}).(AccessControlPolicySpecApiKeyKeysArrayOutput)
}

// ForwardHeaders instructs the middleware to forward key metadata as header values upon successful authentication.
type AccessControlPolicySpecApiKeyForwardHeaders struct {
}

// KeySource defines how to extract API keys from requests.
type AccessControlPolicySpecApiKeyKeySource struct {
	// Cookie is the name of a cookie.
	Cookie *string `pulumi:"cookie"`
	// Header is the name of a header.
	Header *string `pulumi:"header"`
	// HeaderAuthScheme sets an optional auth scheme when Header is set to "Authorization".
	// If set, this scheme is removed from the token, and all requests not including it are dropped.
	HeaderAuthScheme *string `pulumi:"headerAuthScheme"`
	// Query is the name of a query parameter.
	Query *string `pulumi:"query"`
}

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

	ToAccessControlPolicySpecApiKeyKeySourceOutput() AccessControlPolicySpecApiKeyKeySourceOutput
	ToAccessControlPolicySpecApiKeyKeySourceOutputWithContext(context.Context) AccessControlPolicySpecApiKeyKeySourceOutput
}

// KeySource defines how to extract API keys from requests.
type AccessControlPolicySpecApiKeyKeySourceArgs struct {
	// Cookie is the name of a cookie.
	Cookie pulumi.StringPtrInput `pulumi:"cookie"`
	// Header is the name of a header.
	Header pulumi.StringPtrInput `pulumi:"header"`
	// HeaderAuthScheme sets an optional auth scheme when Header is set to "Authorization".
	// If set, this scheme is removed from the token, and all requests not including it are dropped.
	HeaderAuthScheme pulumi.StringPtrInput `pulumi:"headerAuthScheme"`
	// Query is the name of a query parameter.
	Query pulumi.StringPtrInput `pulumi:"query"`
}

func (AccessControlPolicySpecApiKeyKeySourceArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecApiKeyKeySource)(nil)).Elem()
}

func (i AccessControlPolicySpecApiKeyKeySourceArgs) ToAccessControlPolicySpecApiKeyKeySourceOutput() AccessControlPolicySpecApiKeyKeySourceOutput {
	return i.ToAccessControlPolicySpecApiKeyKeySourceOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecApiKeyKeySourceArgs) ToAccessControlPolicySpecApiKeyKeySourceOutputWithContext(ctx context.Context) AccessControlPolicySpecApiKeyKeySourceOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecApiKeyKeySourceOutput)
}

func (i AccessControlPolicySpecApiKeyKeySourceArgs) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecApiKeyKeySource] {
	return pulumix.Output[AccessControlPolicySpecApiKeyKeySource]{
		OutputState: i.ToAccessControlPolicySpecApiKeyKeySourceOutputWithContext(ctx).OutputState,
	}
}

func (i AccessControlPolicySpecApiKeyKeySourceArgs) ToAccessControlPolicySpecApiKeyKeySourcePtrOutput() AccessControlPolicySpecApiKeyKeySourcePtrOutput {
	return i.ToAccessControlPolicySpecApiKeyKeySourcePtrOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecApiKeyKeySourceArgs) ToAccessControlPolicySpecApiKeyKeySourcePtrOutputWithContext(ctx context.Context) AccessControlPolicySpecApiKeyKeySourcePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecApiKeyKeySourceOutput).ToAccessControlPolicySpecApiKeyKeySourcePtrOutputWithContext(ctx)
}

// AccessControlPolicySpecApiKeyKeySourcePtrInput is an input type that accepts AccessControlPolicySpecApiKeyKeySourceArgs, AccessControlPolicySpecApiKeyKeySourcePtr and AccessControlPolicySpecApiKeyKeySourcePtrOutput values.
// You can construct a concrete instance of `AccessControlPolicySpecApiKeyKeySourcePtrInput` via:
//
//	        AccessControlPolicySpecApiKeyKeySourceArgs{...}
//
//	or:
//
//	        nil
type AccessControlPolicySpecApiKeyKeySourcePtrInput interface {
	pulumi.Input

	ToAccessControlPolicySpecApiKeyKeySourcePtrOutput() AccessControlPolicySpecApiKeyKeySourcePtrOutput
	ToAccessControlPolicySpecApiKeyKeySourcePtrOutputWithContext(context.Context) AccessControlPolicySpecApiKeyKeySourcePtrOutput
}

type accessControlPolicySpecApiKeyKeySourcePtrType AccessControlPolicySpecApiKeyKeySourceArgs

func AccessControlPolicySpecApiKeyKeySourcePtr(v *AccessControlPolicySpecApiKeyKeySourceArgs) AccessControlPolicySpecApiKeyKeySourcePtrInput {
	return (*accessControlPolicySpecApiKeyKeySourcePtrType)(v)
}

func (*accessControlPolicySpecApiKeyKeySourcePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecApiKeyKeySource)(nil)).Elem()
}

func (i *accessControlPolicySpecApiKeyKeySourcePtrType) ToAccessControlPolicySpecApiKeyKeySourcePtrOutput() AccessControlPolicySpecApiKeyKeySourcePtrOutput {
	return i.ToAccessControlPolicySpecApiKeyKeySourcePtrOutputWithContext(context.Background())
}

func (i *accessControlPolicySpecApiKeyKeySourcePtrType) ToAccessControlPolicySpecApiKeyKeySourcePtrOutputWithContext(ctx context.Context) AccessControlPolicySpecApiKeyKeySourcePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecApiKeyKeySourcePtrOutput)
}

func (i *accessControlPolicySpecApiKeyKeySourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecApiKeyKeySource] {
	return pulumix.Output[*AccessControlPolicySpecApiKeyKeySource]{
		OutputState: i.ToAccessControlPolicySpecApiKeyKeySourcePtrOutputWithContext(ctx).OutputState,
	}
}

// KeySource defines how to extract API keys from requests.
type AccessControlPolicySpecApiKeyKeySourceOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecApiKeyKeySourceOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecApiKeyKeySource)(nil)).Elem()
}

func (o AccessControlPolicySpecApiKeyKeySourceOutput) ToAccessControlPolicySpecApiKeyKeySourceOutput() AccessControlPolicySpecApiKeyKeySourceOutput {
	return o
}

func (o AccessControlPolicySpecApiKeyKeySourceOutput) ToAccessControlPolicySpecApiKeyKeySourceOutputWithContext(ctx context.Context) AccessControlPolicySpecApiKeyKeySourceOutput {
	return o
}

func (o AccessControlPolicySpecApiKeyKeySourceOutput) ToAccessControlPolicySpecApiKeyKeySourcePtrOutput() AccessControlPolicySpecApiKeyKeySourcePtrOutput {
	return o.ToAccessControlPolicySpecApiKeyKeySourcePtrOutputWithContext(context.Background())
}

func (o AccessControlPolicySpecApiKeyKeySourceOutput) ToAccessControlPolicySpecApiKeyKeySourcePtrOutputWithContext(ctx context.Context) AccessControlPolicySpecApiKeyKeySourcePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v AccessControlPolicySpecApiKeyKeySource) *AccessControlPolicySpecApiKeyKeySource {
		return &v
	}).(AccessControlPolicySpecApiKeyKeySourcePtrOutput)
}

func (o AccessControlPolicySpecApiKeyKeySourceOutput) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecApiKeyKeySource] {
	return pulumix.Output[AccessControlPolicySpecApiKeyKeySource]{
		OutputState: o.OutputState,
	}
}

// Cookie is the name of a cookie.
func (o AccessControlPolicySpecApiKeyKeySourceOutput) Cookie() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecApiKeyKeySource) *string { return v.Cookie }).(pulumi.StringPtrOutput)
}

// Header is the name of a header.
func (o AccessControlPolicySpecApiKeyKeySourceOutput) Header() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecApiKeyKeySource) *string { return v.Header }).(pulumi.StringPtrOutput)
}

// HeaderAuthScheme sets an optional auth scheme when Header is set to "Authorization".
// If set, this scheme is removed from the token, and all requests not including it are dropped.
func (o AccessControlPolicySpecApiKeyKeySourceOutput) HeaderAuthScheme() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecApiKeyKeySource) *string { return v.HeaderAuthScheme }).(pulumi.StringPtrOutput)
}

// Query is the name of a query parameter.
func (o AccessControlPolicySpecApiKeyKeySourceOutput) Query() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecApiKeyKeySource) *string { return v.Query }).(pulumi.StringPtrOutput)
}

type AccessControlPolicySpecApiKeyKeySourcePtrOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecApiKeyKeySourcePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecApiKeyKeySource)(nil)).Elem()
}

func (o AccessControlPolicySpecApiKeyKeySourcePtrOutput) ToAccessControlPolicySpecApiKeyKeySourcePtrOutput() AccessControlPolicySpecApiKeyKeySourcePtrOutput {
	return o
}

func (o AccessControlPolicySpecApiKeyKeySourcePtrOutput) ToAccessControlPolicySpecApiKeyKeySourcePtrOutputWithContext(ctx context.Context) AccessControlPolicySpecApiKeyKeySourcePtrOutput {
	return o
}

func (o AccessControlPolicySpecApiKeyKeySourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecApiKeyKeySource] {
	return pulumix.Output[*AccessControlPolicySpecApiKeyKeySource]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicySpecApiKeyKeySourcePtrOutput) Elem() AccessControlPolicySpecApiKeyKeySourceOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecApiKeyKeySource) AccessControlPolicySpecApiKeyKeySource {
		if v != nil {
			return *v
		}
		var ret AccessControlPolicySpecApiKeyKeySource
		return ret
	}).(AccessControlPolicySpecApiKeyKeySourceOutput)
}

// Cookie is the name of a cookie.
func (o AccessControlPolicySpecApiKeyKeySourcePtrOutput) Cookie() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecApiKeyKeySource) *string {
		if v == nil {
			return nil
		}
		return v.Cookie
	}).(pulumi.StringPtrOutput)
}

// Header is the name of a header.
func (o AccessControlPolicySpecApiKeyKeySourcePtrOutput) Header() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecApiKeyKeySource) *string {
		if v == nil {
			return nil
		}
		return v.Header
	}).(pulumi.StringPtrOutput)
}

// HeaderAuthScheme sets an optional auth scheme when Header is set to "Authorization".
// If set, this scheme is removed from the token, and all requests not including it are dropped.
func (o AccessControlPolicySpecApiKeyKeySourcePtrOutput) HeaderAuthScheme() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecApiKeyKeySource) *string {
		if v == nil {
			return nil
		}
		return v.HeaderAuthScheme
	}).(pulumi.StringPtrOutput)
}

// Query is the name of a query parameter.
func (o AccessControlPolicySpecApiKeyKeySourcePtrOutput) Query() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecApiKeyKeySource) *string {
		if v == nil {
			return nil
		}
		return v.Query
	}).(pulumi.StringPtrOutput)
}

// AccessControlPolicyAPIKeyKey defines an API key.
type AccessControlPolicySpecApiKeyKeys struct {
	// ID is the unique identifier of the key.
	Id string `pulumi:"id"`
	// Metadata holds arbitrary metadata for this key, can be used by ForwardHeaders.
	Metadata map[string]string `pulumi:"metadata"`
	// Value is the SHAKE-256 hash (using 64 bytes) of the API key.
	Value string `pulumi:"value"`
}

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

	ToAccessControlPolicySpecApiKeyKeysOutput() AccessControlPolicySpecApiKeyKeysOutput
	ToAccessControlPolicySpecApiKeyKeysOutputWithContext(context.Context) AccessControlPolicySpecApiKeyKeysOutput
}

// AccessControlPolicyAPIKeyKey defines an API key.
type AccessControlPolicySpecApiKeyKeysArgs struct {
	// ID is the unique identifier of the key.
	Id pulumi.StringInput `pulumi:"id"`
	// Metadata holds arbitrary metadata for this key, can be used by ForwardHeaders.
	Metadata pulumi.StringMapInput `pulumi:"metadata"`
	// Value is the SHAKE-256 hash (using 64 bytes) of the API key.
	Value pulumi.StringInput `pulumi:"value"`
}

func (AccessControlPolicySpecApiKeyKeysArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecApiKeyKeys)(nil)).Elem()
}

func (i AccessControlPolicySpecApiKeyKeysArgs) ToAccessControlPolicySpecApiKeyKeysOutput() AccessControlPolicySpecApiKeyKeysOutput {
	return i.ToAccessControlPolicySpecApiKeyKeysOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecApiKeyKeysArgs) ToAccessControlPolicySpecApiKeyKeysOutputWithContext(ctx context.Context) AccessControlPolicySpecApiKeyKeysOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecApiKeyKeysOutput)
}

func (i AccessControlPolicySpecApiKeyKeysArgs) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecApiKeyKeys] {
	return pulumix.Output[AccessControlPolicySpecApiKeyKeys]{
		OutputState: i.ToAccessControlPolicySpecApiKeyKeysOutputWithContext(ctx).OutputState,
	}
}

// AccessControlPolicySpecApiKeyKeysArrayInput is an input type that accepts AccessControlPolicySpecApiKeyKeysArray and AccessControlPolicySpecApiKeyKeysArrayOutput values.
// You can construct a concrete instance of `AccessControlPolicySpecApiKeyKeysArrayInput` via:
//
//	AccessControlPolicySpecApiKeyKeysArray{ AccessControlPolicySpecApiKeyKeysArgs{...} }
type AccessControlPolicySpecApiKeyKeysArrayInput interface {
	pulumi.Input

	ToAccessControlPolicySpecApiKeyKeysArrayOutput() AccessControlPolicySpecApiKeyKeysArrayOutput
	ToAccessControlPolicySpecApiKeyKeysArrayOutputWithContext(context.Context) AccessControlPolicySpecApiKeyKeysArrayOutput
}

type AccessControlPolicySpecApiKeyKeysArray []AccessControlPolicySpecApiKeyKeysInput

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

func (i AccessControlPolicySpecApiKeyKeysArray) ToAccessControlPolicySpecApiKeyKeysArrayOutput() AccessControlPolicySpecApiKeyKeysArrayOutput {
	return i.ToAccessControlPolicySpecApiKeyKeysArrayOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecApiKeyKeysArray) ToAccessControlPolicySpecApiKeyKeysArrayOutputWithContext(ctx context.Context) AccessControlPolicySpecApiKeyKeysArrayOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecApiKeyKeysArrayOutput)
}

func (i AccessControlPolicySpecApiKeyKeysArray) ToOutput(ctx context.Context) pulumix.Output[[]AccessControlPolicySpecApiKeyKeys] {
	return pulumix.Output[[]AccessControlPolicySpecApiKeyKeys]{
		OutputState: i.ToAccessControlPolicySpecApiKeyKeysArrayOutputWithContext(ctx).OutputState,
	}
}

// AccessControlPolicyAPIKeyKey defines an API key.
type AccessControlPolicySpecApiKeyKeysOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecApiKeyKeysOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecApiKeyKeys)(nil)).Elem()
}

func (o AccessControlPolicySpecApiKeyKeysOutput) ToAccessControlPolicySpecApiKeyKeysOutput() AccessControlPolicySpecApiKeyKeysOutput {
	return o
}

func (o AccessControlPolicySpecApiKeyKeysOutput) ToAccessControlPolicySpecApiKeyKeysOutputWithContext(ctx context.Context) AccessControlPolicySpecApiKeyKeysOutput {
	return o
}

func (o AccessControlPolicySpecApiKeyKeysOutput) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecApiKeyKeys] {
	return pulumix.Output[AccessControlPolicySpecApiKeyKeys]{
		OutputState: o.OutputState,
	}
}

// ID is the unique identifier of the key.
func (o AccessControlPolicySpecApiKeyKeysOutput) Id() pulumi.StringOutput {
	return o.ApplyT(func(v AccessControlPolicySpecApiKeyKeys) string { return v.Id }).(pulumi.StringOutput)
}

// Metadata holds arbitrary metadata for this key, can be used by ForwardHeaders.
func (o AccessControlPolicySpecApiKeyKeysOutput) Metadata() pulumi.StringMapOutput {
	return o.ApplyT(func(v AccessControlPolicySpecApiKeyKeys) map[string]string { return v.Metadata }).(pulumi.StringMapOutput)
}

// Value is the SHAKE-256 hash (using 64 bytes) of the API key.
func (o AccessControlPolicySpecApiKeyKeysOutput) Value() pulumi.StringOutput {
	return o.ApplyT(func(v AccessControlPolicySpecApiKeyKeys) string { return v.Value }).(pulumi.StringOutput)
}

type AccessControlPolicySpecApiKeyKeysArrayOutput struct{ *pulumi.OutputState }

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

func (o AccessControlPolicySpecApiKeyKeysArrayOutput) ToAccessControlPolicySpecApiKeyKeysArrayOutput() AccessControlPolicySpecApiKeyKeysArrayOutput {
	return o
}

func (o AccessControlPolicySpecApiKeyKeysArrayOutput) ToAccessControlPolicySpecApiKeyKeysArrayOutputWithContext(ctx context.Context) AccessControlPolicySpecApiKeyKeysArrayOutput {
	return o
}

func (o AccessControlPolicySpecApiKeyKeysArrayOutput) ToOutput(ctx context.Context) pulumix.Output[[]AccessControlPolicySpecApiKeyKeys] {
	return pulumix.Output[[]AccessControlPolicySpecApiKeyKeys]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicySpecApiKeyKeysArrayOutput) Index(i pulumi.IntInput) AccessControlPolicySpecApiKeyKeysOutput {
	return pulumi.All(o, i).ApplyT(func(vs []interface{}) AccessControlPolicySpecApiKeyKeys {
		return vs[0].([]AccessControlPolicySpecApiKeyKeys)[vs[1].(int)]
	}).(AccessControlPolicySpecApiKeyKeysOutput)
}

// Metadata holds arbitrary metadata for this key, can be used by ForwardHeaders.
type AccessControlPolicySpecApiKeyKeysMetadata struct {
}

// AccessControlPolicyBasicAuth holds the HTTP basic authentication configuration.
type AccessControlPolicySpecBasicAuth struct {
	ForwardUsernameHeader    *string  `pulumi:"forwardUsernameHeader"`
	Realm                    *string  `pulumi:"realm"`
	StripAuthorizationHeader *bool    `pulumi:"stripAuthorizationHeader"`
	Users                    []string `pulumi:"users"`
}

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

	ToAccessControlPolicySpecBasicAuthOutput() AccessControlPolicySpecBasicAuthOutput
	ToAccessControlPolicySpecBasicAuthOutputWithContext(context.Context) AccessControlPolicySpecBasicAuthOutput
}

// AccessControlPolicyBasicAuth holds the HTTP basic authentication configuration.
type AccessControlPolicySpecBasicAuthArgs struct {
	ForwardUsernameHeader    pulumi.StringPtrInput   `pulumi:"forwardUsernameHeader"`
	Realm                    pulumi.StringPtrInput   `pulumi:"realm"`
	StripAuthorizationHeader pulumi.BoolPtrInput     `pulumi:"stripAuthorizationHeader"`
	Users                    pulumi.StringArrayInput `pulumi:"users"`
}

func (AccessControlPolicySpecBasicAuthArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecBasicAuth)(nil)).Elem()
}

func (i AccessControlPolicySpecBasicAuthArgs) ToAccessControlPolicySpecBasicAuthOutput() AccessControlPolicySpecBasicAuthOutput {
	return i.ToAccessControlPolicySpecBasicAuthOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecBasicAuthArgs) ToAccessControlPolicySpecBasicAuthOutputWithContext(ctx context.Context) AccessControlPolicySpecBasicAuthOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecBasicAuthOutput)
}

func (i AccessControlPolicySpecBasicAuthArgs) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecBasicAuth] {
	return pulumix.Output[AccessControlPolicySpecBasicAuth]{
		OutputState: i.ToAccessControlPolicySpecBasicAuthOutputWithContext(ctx).OutputState,
	}
}

func (i AccessControlPolicySpecBasicAuthArgs) ToAccessControlPolicySpecBasicAuthPtrOutput() AccessControlPolicySpecBasicAuthPtrOutput {
	return i.ToAccessControlPolicySpecBasicAuthPtrOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecBasicAuthArgs) ToAccessControlPolicySpecBasicAuthPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecBasicAuthPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecBasicAuthOutput).ToAccessControlPolicySpecBasicAuthPtrOutputWithContext(ctx)
}

// AccessControlPolicySpecBasicAuthPtrInput is an input type that accepts AccessControlPolicySpecBasicAuthArgs, AccessControlPolicySpecBasicAuthPtr and AccessControlPolicySpecBasicAuthPtrOutput values.
// You can construct a concrete instance of `AccessControlPolicySpecBasicAuthPtrInput` via:
//
//	        AccessControlPolicySpecBasicAuthArgs{...}
//
//	or:
//
//	        nil
type AccessControlPolicySpecBasicAuthPtrInput interface {
	pulumi.Input

	ToAccessControlPolicySpecBasicAuthPtrOutput() AccessControlPolicySpecBasicAuthPtrOutput
	ToAccessControlPolicySpecBasicAuthPtrOutputWithContext(context.Context) AccessControlPolicySpecBasicAuthPtrOutput
}

type accessControlPolicySpecBasicAuthPtrType AccessControlPolicySpecBasicAuthArgs

func AccessControlPolicySpecBasicAuthPtr(v *AccessControlPolicySpecBasicAuthArgs) AccessControlPolicySpecBasicAuthPtrInput {
	return (*accessControlPolicySpecBasicAuthPtrType)(v)
}

func (*accessControlPolicySpecBasicAuthPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecBasicAuth)(nil)).Elem()
}

func (i *accessControlPolicySpecBasicAuthPtrType) ToAccessControlPolicySpecBasicAuthPtrOutput() AccessControlPolicySpecBasicAuthPtrOutput {
	return i.ToAccessControlPolicySpecBasicAuthPtrOutputWithContext(context.Background())
}

func (i *accessControlPolicySpecBasicAuthPtrType) ToAccessControlPolicySpecBasicAuthPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecBasicAuthPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecBasicAuthPtrOutput)
}

func (i *accessControlPolicySpecBasicAuthPtrType) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecBasicAuth] {
	return pulumix.Output[*AccessControlPolicySpecBasicAuth]{
		OutputState: i.ToAccessControlPolicySpecBasicAuthPtrOutputWithContext(ctx).OutputState,
	}
}

// AccessControlPolicyBasicAuth holds the HTTP basic authentication configuration.
type AccessControlPolicySpecBasicAuthOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecBasicAuthOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecBasicAuth)(nil)).Elem()
}

func (o AccessControlPolicySpecBasicAuthOutput) ToAccessControlPolicySpecBasicAuthOutput() AccessControlPolicySpecBasicAuthOutput {
	return o
}

func (o AccessControlPolicySpecBasicAuthOutput) ToAccessControlPolicySpecBasicAuthOutputWithContext(ctx context.Context) AccessControlPolicySpecBasicAuthOutput {
	return o
}

func (o AccessControlPolicySpecBasicAuthOutput) ToAccessControlPolicySpecBasicAuthPtrOutput() AccessControlPolicySpecBasicAuthPtrOutput {
	return o.ToAccessControlPolicySpecBasicAuthPtrOutputWithContext(context.Background())
}

func (o AccessControlPolicySpecBasicAuthOutput) ToAccessControlPolicySpecBasicAuthPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecBasicAuthPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v AccessControlPolicySpecBasicAuth) *AccessControlPolicySpecBasicAuth {
		return &v
	}).(AccessControlPolicySpecBasicAuthPtrOutput)
}

func (o AccessControlPolicySpecBasicAuthOutput) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecBasicAuth] {
	return pulumix.Output[AccessControlPolicySpecBasicAuth]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicySpecBasicAuthOutput) ForwardUsernameHeader() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecBasicAuth) *string { return v.ForwardUsernameHeader }).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecBasicAuthOutput) Realm() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecBasicAuth) *string { return v.Realm }).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecBasicAuthOutput) StripAuthorizationHeader() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecBasicAuth) *bool { return v.StripAuthorizationHeader }).(pulumi.BoolPtrOutput)
}

func (o AccessControlPolicySpecBasicAuthOutput) Users() pulumi.StringArrayOutput {
	return o.ApplyT(func(v AccessControlPolicySpecBasicAuth) []string { return v.Users }).(pulumi.StringArrayOutput)
}

type AccessControlPolicySpecBasicAuthPtrOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecBasicAuthPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecBasicAuth)(nil)).Elem()
}

func (o AccessControlPolicySpecBasicAuthPtrOutput) ToAccessControlPolicySpecBasicAuthPtrOutput() AccessControlPolicySpecBasicAuthPtrOutput {
	return o
}

func (o AccessControlPolicySpecBasicAuthPtrOutput) ToAccessControlPolicySpecBasicAuthPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecBasicAuthPtrOutput {
	return o
}

func (o AccessControlPolicySpecBasicAuthPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecBasicAuth] {
	return pulumix.Output[*AccessControlPolicySpecBasicAuth]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicySpecBasicAuthPtrOutput) Elem() AccessControlPolicySpecBasicAuthOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecBasicAuth) AccessControlPolicySpecBasicAuth {
		if v != nil {
			return *v
		}
		var ret AccessControlPolicySpecBasicAuth
		return ret
	}).(AccessControlPolicySpecBasicAuthOutput)
}

func (o AccessControlPolicySpecBasicAuthPtrOutput) ForwardUsernameHeader() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecBasicAuth) *string {
		if v == nil {
			return nil
		}
		return v.ForwardUsernameHeader
	}).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecBasicAuthPtrOutput) Realm() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecBasicAuth) *string {
		if v == nil {
			return nil
		}
		return v.Realm
	}).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecBasicAuthPtrOutput) StripAuthorizationHeader() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecBasicAuth) *bool {
		if v == nil {
			return nil
		}
		return v.StripAuthorizationHeader
	}).(pulumi.BoolPtrOutput)
}

func (o AccessControlPolicySpecBasicAuthPtrOutput) Users() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecBasicAuth) []string {
		if v == nil {
			return nil
		}
		return v.Users
	}).(pulumi.StringArrayOutput)
}

// AccessControlPolicyJWT configures a JWT access control policy.
type AccessControlPolicySpecJwt struct {
	Claims                     *string           `pulumi:"claims"`
	ForwardHeaders             map[string]string `pulumi:"forwardHeaders"`
	JwksFile                   *string           `pulumi:"jwksFile"`
	JwksUrl                    *string           `pulumi:"jwksUrl"`
	PublicKey                  *string           `pulumi:"publicKey"`
	SigningSecret              *string           `pulumi:"signingSecret"`
	SigningSecretBase64Encoded *bool             `pulumi:"signingSecretBase64Encoded"`
	StripAuthorizationHeader   *bool             `pulumi:"stripAuthorizationHeader"`
	TokenQueryKey              *string           `pulumi:"tokenQueryKey"`
}

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

	ToAccessControlPolicySpecJwtOutput() AccessControlPolicySpecJwtOutput
	ToAccessControlPolicySpecJwtOutputWithContext(context.Context) AccessControlPolicySpecJwtOutput
}

// AccessControlPolicyJWT configures a JWT access control policy.
type AccessControlPolicySpecJwtArgs struct {
	Claims                     pulumi.StringPtrInput `pulumi:"claims"`
	ForwardHeaders             pulumi.StringMapInput `pulumi:"forwardHeaders"`
	JwksFile                   pulumi.StringPtrInput `pulumi:"jwksFile"`
	JwksUrl                    pulumi.StringPtrInput `pulumi:"jwksUrl"`
	PublicKey                  pulumi.StringPtrInput `pulumi:"publicKey"`
	SigningSecret              pulumi.StringPtrInput `pulumi:"signingSecret"`
	SigningSecretBase64Encoded pulumi.BoolPtrInput   `pulumi:"signingSecretBase64Encoded"`
	StripAuthorizationHeader   pulumi.BoolPtrInput   `pulumi:"stripAuthorizationHeader"`
	TokenQueryKey              pulumi.StringPtrInput `pulumi:"tokenQueryKey"`
}

func (AccessControlPolicySpecJwtArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecJwt)(nil)).Elem()
}

func (i AccessControlPolicySpecJwtArgs) ToAccessControlPolicySpecJwtOutput() AccessControlPolicySpecJwtOutput {
	return i.ToAccessControlPolicySpecJwtOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecJwtArgs) ToAccessControlPolicySpecJwtOutputWithContext(ctx context.Context) AccessControlPolicySpecJwtOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecJwtOutput)
}

func (i AccessControlPolicySpecJwtArgs) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecJwt] {
	return pulumix.Output[AccessControlPolicySpecJwt]{
		OutputState: i.ToAccessControlPolicySpecJwtOutputWithContext(ctx).OutputState,
	}
}

func (i AccessControlPolicySpecJwtArgs) ToAccessControlPolicySpecJwtPtrOutput() AccessControlPolicySpecJwtPtrOutput {
	return i.ToAccessControlPolicySpecJwtPtrOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecJwtArgs) ToAccessControlPolicySpecJwtPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecJwtPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecJwtOutput).ToAccessControlPolicySpecJwtPtrOutputWithContext(ctx)
}

// AccessControlPolicySpecJwtPtrInput is an input type that accepts AccessControlPolicySpecJwtArgs, AccessControlPolicySpecJwtPtr and AccessControlPolicySpecJwtPtrOutput values.
// You can construct a concrete instance of `AccessControlPolicySpecJwtPtrInput` via:
//
//	        AccessControlPolicySpecJwtArgs{...}
//
//	or:
//
//	        nil
type AccessControlPolicySpecJwtPtrInput interface {
	pulumi.Input

	ToAccessControlPolicySpecJwtPtrOutput() AccessControlPolicySpecJwtPtrOutput
	ToAccessControlPolicySpecJwtPtrOutputWithContext(context.Context) AccessControlPolicySpecJwtPtrOutput
}

type accessControlPolicySpecJwtPtrType AccessControlPolicySpecJwtArgs

func AccessControlPolicySpecJwtPtr(v *AccessControlPolicySpecJwtArgs) AccessControlPolicySpecJwtPtrInput {
	return (*accessControlPolicySpecJwtPtrType)(v)
}

func (*accessControlPolicySpecJwtPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecJwt)(nil)).Elem()
}

func (i *accessControlPolicySpecJwtPtrType) ToAccessControlPolicySpecJwtPtrOutput() AccessControlPolicySpecJwtPtrOutput {
	return i.ToAccessControlPolicySpecJwtPtrOutputWithContext(context.Background())
}

func (i *accessControlPolicySpecJwtPtrType) ToAccessControlPolicySpecJwtPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecJwtPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecJwtPtrOutput)
}

func (i *accessControlPolicySpecJwtPtrType) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecJwt] {
	return pulumix.Output[*AccessControlPolicySpecJwt]{
		OutputState: i.ToAccessControlPolicySpecJwtPtrOutputWithContext(ctx).OutputState,
	}
}

// AccessControlPolicyJWT configures a JWT access control policy.
type AccessControlPolicySpecJwtOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecJwtOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecJwt)(nil)).Elem()
}

func (o AccessControlPolicySpecJwtOutput) ToAccessControlPolicySpecJwtOutput() AccessControlPolicySpecJwtOutput {
	return o
}

func (o AccessControlPolicySpecJwtOutput) ToAccessControlPolicySpecJwtOutputWithContext(ctx context.Context) AccessControlPolicySpecJwtOutput {
	return o
}

func (o AccessControlPolicySpecJwtOutput) ToAccessControlPolicySpecJwtPtrOutput() AccessControlPolicySpecJwtPtrOutput {
	return o.ToAccessControlPolicySpecJwtPtrOutputWithContext(context.Background())
}

func (o AccessControlPolicySpecJwtOutput) ToAccessControlPolicySpecJwtPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecJwtPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v AccessControlPolicySpecJwt) *AccessControlPolicySpecJwt {
		return &v
	}).(AccessControlPolicySpecJwtPtrOutput)
}

func (o AccessControlPolicySpecJwtOutput) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecJwt] {
	return pulumix.Output[AccessControlPolicySpecJwt]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicySpecJwtOutput) Claims() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecJwt) *string { return v.Claims }).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecJwtOutput) ForwardHeaders() pulumi.StringMapOutput {
	return o.ApplyT(func(v AccessControlPolicySpecJwt) map[string]string { return v.ForwardHeaders }).(pulumi.StringMapOutput)
}

func (o AccessControlPolicySpecJwtOutput) JwksFile() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecJwt) *string { return v.JwksFile }).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecJwtOutput) JwksUrl() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecJwt) *string { return v.JwksUrl }).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecJwtOutput) PublicKey() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecJwt) *string { return v.PublicKey }).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecJwtOutput) SigningSecret() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecJwt) *string { return v.SigningSecret }).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecJwtOutput) SigningSecretBase64Encoded() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecJwt) *bool { return v.SigningSecretBase64Encoded }).(pulumi.BoolPtrOutput)
}

func (o AccessControlPolicySpecJwtOutput) StripAuthorizationHeader() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecJwt) *bool { return v.StripAuthorizationHeader }).(pulumi.BoolPtrOutput)
}

func (o AccessControlPolicySpecJwtOutput) TokenQueryKey() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecJwt) *string { return v.TokenQueryKey }).(pulumi.StringPtrOutput)
}

type AccessControlPolicySpecJwtPtrOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecJwtPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecJwt)(nil)).Elem()
}

func (o AccessControlPolicySpecJwtPtrOutput) ToAccessControlPolicySpecJwtPtrOutput() AccessControlPolicySpecJwtPtrOutput {
	return o
}

func (o AccessControlPolicySpecJwtPtrOutput) ToAccessControlPolicySpecJwtPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecJwtPtrOutput {
	return o
}

func (o AccessControlPolicySpecJwtPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecJwt] {
	return pulumix.Output[*AccessControlPolicySpecJwt]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicySpecJwtPtrOutput) Elem() AccessControlPolicySpecJwtOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecJwt) AccessControlPolicySpecJwt {
		if v != nil {
			return *v
		}
		var ret AccessControlPolicySpecJwt
		return ret
	}).(AccessControlPolicySpecJwtOutput)
}

func (o AccessControlPolicySpecJwtPtrOutput) Claims() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecJwt) *string {
		if v == nil {
			return nil
		}
		return v.Claims
	}).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecJwtPtrOutput) ForwardHeaders() pulumi.StringMapOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecJwt) map[string]string {
		if v == nil {
			return nil
		}
		return v.ForwardHeaders
	}).(pulumi.StringMapOutput)
}

func (o AccessControlPolicySpecJwtPtrOutput) JwksFile() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecJwt) *string {
		if v == nil {
			return nil
		}
		return v.JwksFile
	}).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecJwtPtrOutput) JwksUrl() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecJwt) *string {
		if v == nil {
			return nil
		}
		return v.JwksUrl
	}).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecJwtPtrOutput) PublicKey() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecJwt) *string {
		if v == nil {
			return nil
		}
		return v.PublicKey
	}).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecJwtPtrOutput) SigningSecret() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecJwt) *string {
		if v == nil {
			return nil
		}
		return v.SigningSecret
	}).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecJwtPtrOutput) SigningSecretBase64Encoded() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecJwt) *bool {
		if v == nil {
			return nil
		}
		return v.SigningSecretBase64Encoded
	}).(pulumi.BoolPtrOutput)
}

func (o AccessControlPolicySpecJwtPtrOutput) StripAuthorizationHeader() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecJwt) *bool {
		if v == nil {
			return nil
		}
		return v.StripAuthorizationHeader
	}).(pulumi.BoolPtrOutput)
}

func (o AccessControlPolicySpecJwtPtrOutput) TokenQueryKey() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecJwt) *string {
		if v == nil {
			return nil
		}
		return v.TokenQueryKey
	}).(pulumi.StringPtrOutput)
}

type AccessControlPolicySpecJwtForwardHeaders struct {
}

// AccessControlOAuthIntro configures an OAuth 2.0 Token Introspection access control policy.
type AccessControlPolicySpecOAuthIntro struct {
	Claims *string `pulumi:"claims"`
	// AccessControlOAuthIntroClientConfig configures the OAuth 2.0 client for issuing token introspection requests.
	ClientConfig   AccessControlPolicySpecOAuthIntroClientConfig `pulumi:"clientConfig"`
	ForwardHeaders map[string]string                             `pulumi:"forwardHeaders"`
	// TokenSource describes how to extract tokens from HTTP requests.
	// If multiple sources are set, the order is the following: header > query > cookie.
	TokenSource AccessControlPolicySpecOAuthIntroTokenSource `pulumi:"tokenSource"`
}

// Defaults sets the appropriate defaults for AccessControlPolicySpecOAuthIntro
func (val *AccessControlPolicySpecOAuthIntro) Defaults() *AccessControlPolicySpecOAuthIntro {
	if val == nil {
		return nil
	}
	tmp := *val
	tmp.ClientConfig = *tmp.ClientConfig.Defaults()

	return &tmp
}

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

	ToAccessControlPolicySpecOAuthIntroOutput() AccessControlPolicySpecOAuthIntroOutput
	ToAccessControlPolicySpecOAuthIntroOutputWithContext(context.Context) AccessControlPolicySpecOAuthIntroOutput
}

// AccessControlOAuthIntro configures an OAuth 2.0 Token Introspection access control policy.
type AccessControlPolicySpecOAuthIntroArgs struct {
	Claims pulumi.StringPtrInput `pulumi:"claims"`
	// AccessControlOAuthIntroClientConfig configures the OAuth 2.0 client for issuing token introspection requests.
	ClientConfig   AccessControlPolicySpecOAuthIntroClientConfigInput `pulumi:"clientConfig"`
	ForwardHeaders pulumi.StringMapInput                              `pulumi:"forwardHeaders"`
	// TokenSource describes how to extract tokens from HTTP requests.
	// If multiple sources are set, the order is the following: header > query > cookie.
	TokenSource AccessControlPolicySpecOAuthIntroTokenSourceInput `pulumi:"tokenSource"`
}

// Defaults sets the appropriate defaults for AccessControlPolicySpecOAuthIntroArgs
func (val *AccessControlPolicySpecOAuthIntroArgs) Defaults() *AccessControlPolicySpecOAuthIntroArgs {
	if val == nil {
		return nil
	}
	tmp := *val

	return &tmp
}
func (AccessControlPolicySpecOAuthIntroArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecOAuthIntro)(nil)).Elem()
}

func (i AccessControlPolicySpecOAuthIntroArgs) ToAccessControlPolicySpecOAuthIntroOutput() AccessControlPolicySpecOAuthIntroOutput {
	return i.ToAccessControlPolicySpecOAuthIntroOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecOAuthIntroArgs) ToAccessControlPolicySpecOAuthIntroOutputWithContext(ctx context.Context) AccessControlPolicySpecOAuthIntroOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOAuthIntroOutput)
}

func (i AccessControlPolicySpecOAuthIntroArgs) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecOAuthIntro] {
	return pulumix.Output[AccessControlPolicySpecOAuthIntro]{
		OutputState: i.ToAccessControlPolicySpecOAuthIntroOutputWithContext(ctx).OutputState,
	}
}

func (i AccessControlPolicySpecOAuthIntroArgs) ToAccessControlPolicySpecOAuthIntroPtrOutput() AccessControlPolicySpecOAuthIntroPtrOutput {
	return i.ToAccessControlPolicySpecOAuthIntroPtrOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecOAuthIntroArgs) ToAccessControlPolicySpecOAuthIntroPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOAuthIntroPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOAuthIntroOutput).ToAccessControlPolicySpecOAuthIntroPtrOutputWithContext(ctx)
}

// AccessControlPolicySpecOAuthIntroPtrInput is an input type that accepts AccessControlPolicySpecOAuthIntroArgs, AccessControlPolicySpecOAuthIntroPtr and AccessControlPolicySpecOAuthIntroPtrOutput values.
// You can construct a concrete instance of `AccessControlPolicySpecOAuthIntroPtrInput` via:
//
//	        AccessControlPolicySpecOAuthIntroArgs{...}
//
//	or:
//
//	        nil
type AccessControlPolicySpecOAuthIntroPtrInput interface {
	pulumi.Input

	ToAccessControlPolicySpecOAuthIntroPtrOutput() AccessControlPolicySpecOAuthIntroPtrOutput
	ToAccessControlPolicySpecOAuthIntroPtrOutputWithContext(context.Context) AccessControlPolicySpecOAuthIntroPtrOutput
}

type accessControlPolicySpecOAuthIntroPtrType AccessControlPolicySpecOAuthIntroArgs

func AccessControlPolicySpecOAuthIntroPtr(v *AccessControlPolicySpecOAuthIntroArgs) AccessControlPolicySpecOAuthIntroPtrInput {
	return (*accessControlPolicySpecOAuthIntroPtrType)(v)
}

func (*accessControlPolicySpecOAuthIntroPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecOAuthIntro)(nil)).Elem()
}

func (i *accessControlPolicySpecOAuthIntroPtrType) ToAccessControlPolicySpecOAuthIntroPtrOutput() AccessControlPolicySpecOAuthIntroPtrOutput {
	return i.ToAccessControlPolicySpecOAuthIntroPtrOutputWithContext(context.Background())
}

func (i *accessControlPolicySpecOAuthIntroPtrType) ToAccessControlPolicySpecOAuthIntroPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOAuthIntroPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOAuthIntroPtrOutput)
}

func (i *accessControlPolicySpecOAuthIntroPtrType) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecOAuthIntro] {
	return pulumix.Output[*AccessControlPolicySpecOAuthIntro]{
		OutputState: i.ToAccessControlPolicySpecOAuthIntroPtrOutputWithContext(ctx).OutputState,
	}
}

// AccessControlOAuthIntro configures an OAuth 2.0 Token Introspection access control policy.
type AccessControlPolicySpecOAuthIntroOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecOAuthIntroOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecOAuthIntro)(nil)).Elem()
}

func (o AccessControlPolicySpecOAuthIntroOutput) ToAccessControlPolicySpecOAuthIntroOutput() AccessControlPolicySpecOAuthIntroOutput {
	return o
}

func (o AccessControlPolicySpecOAuthIntroOutput) ToAccessControlPolicySpecOAuthIntroOutputWithContext(ctx context.Context) AccessControlPolicySpecOAuthIntroOutput {
	return o
}

func (o AccessControlPolicySpecOAuthIntroOutput) ToAccessControlPolicySpecOAuthIntroPtrOutput() AccessControlPolicySpecOAuthIntroPtrOutput {
	return o.ToAccessControlPolicySpecOAuthIntroPtrOutputWithContext(context.Background())
}

func (o AccessControlPolicySpecOAuthIntroOutput) ToAccessControlPolicySpecOAuthIntroPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOAuthIntroPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v AccessControlPolicySpecOAuthIntro) *AccessControlPolicySpecOAuthIntro {
		return &v
	}).(AccessControlPolicySpecOAuthIntroPtrOutput)
}

func (o AccessControlPolicySpecOAuthIntroOutput) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecOAuthIntro] {
	return pulumix.Output[AccessControlPolicySpecOAuthIntro]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicySpecOAuthIntroOutput) Claims() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOAuthIntro) *string { return v.Claims }).(pulumi.StringPtrOutput)
}

// AccessControlOAuthIntroClientConfig configures the OAuth 2.0 client for issuing token introspection requests.
func (o AccessControlPolicySpecOAuthIntroOutput) ClientConfig() AccessControlPolicySpecOAuthIntroClientConfigOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOAuthIntro) AccessControlPolicySpecOAuthIntroClientConfig {
		return v.ClientConfig
	}).(AccessControlPolicySpecOAuthIntroClientConfigOutput)
}

func (o AccessControlPolicySpecOAuthIntroOutput) ForwardHeaders() pulumi.StringMapOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOAuthIntro) map[string]string { return v.ForwardHeaders }).(pulumi.StringMapOutput)
}

// TokenSource describes how to extract tokens from HTTP requests.
// If multiple sources are set, the order is the following: header > query > cookie.
func (o AccessControlPolicySpecOAuthIntroOutput) TokenSource() AccessControlPolicySpecOAuthIntroTokenSourceOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOAuthIntro) AccessControlPolicySpecOAuthIntroTokenSource {
		return v.TokenSource
	}).(AccessControlPolicySpecOAuthIntroTokenSourceOutput)
}

type AccessControlPolicySpecOAuthIntroPtrOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecOAuthIntroPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecOAuthIntro)(nil)).Elem()
}

func (o AccessControlPolicySpecOAuthIntroPtrOutput) ToAccessControlPolicySpecOAuthIntroPtrOutput() AccessControlPolicySpecOAuthIntroPtrOutput {
	return o
}

func (o AccessControlPolicySpecOAuthIntroPtrOutput) ToAccessControlPolicySpecOAuthIntroPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOAuthIntroPtrOutput {
	return o
}

func (o AccessControlPolicySpecOAuthIntroPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecOAuthIntro] {
	return pulumix.Output[*AccessControlPolicySpecOAuthIntro]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicySpecOAuthIntroPtrOutput) Elem() AccessControlPolicySpecOAuthIntroOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOAuthIntro) AccessControlPolicySpecOAuthIntro {
		if v != nil {
			return *v
		}
		var ret AccessControlPolicySpecOAuthIntro
		return ret
	}).(AccessControlPolicySpecOAuthIntroOutput)
}

func (o AccessControlPolicySpecOAuthIntroPtrOutput) Claims() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOAuthIntro) *string {
		if v == nil {
			return nil
		}
		return v.Claims
	}).(pulumi.StringPtrOutput)
}

// AccessControlOAuthIntroClientConfig configures the OAuth 2.0 client for issuing token introspection requests.
func (o AccessControlPolicySpecOAuthIntroPtrOutput) ClientConfig() AccessControlPolicySpecOAuthIntroClientConfigPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOAuthIntro) *AccessControlPolicySpecOAuthIntroClientConfig {
		if v == nil {
			return nil
		}
		return &v.ClientConfig
	}).(AccessControlPolicySpecOAuthIntroClientConfigPtrOutput)
}

func (o AccessControlPolicySpecOAuthIntroPtrOutput) ForwardHeaders() pulumi.StringMapOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOAuthIntro) map[string]string {
		if v == nil {
			return nil
		}
		return v.ForwardHeaders
	}).(pulumi.StringMapOutput)
}

// TokenSource describes how to extract tokens from HTTP requests.
// If multiple sources are set, the order is the following: header > query > cookie.
func (o AccessControlPolicySpecOAuthIntroPtrOutput) TokenSource() AccessControlPolicySpecOAuthIntroTokenSourcePtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOAuthIntro) *AccessControlPolicySpecOAuthIntroTokenSource {
		if v == nil {
			return nil
		}
		return &v.TokenSource
	}).(AccessControlPolicySpecOAuthIntroTokenSourcePtrOutput)
}

// AccessControlOAuthIntroClientConfig configures the OAuth 2.0 client for issuing token introspection requests.
type AccessControlPolicySpecOAuthIntroClientConfig struct {
	// Headers to set when sending requests to the Authorization Server.
	Headers map[string]string `pulumi:"headers"`
	// MaxRetries defines the number of retries for introspection requests.
	MaxRetries *int `pulumi:"maxRetries"`
	// TimeoutSeconds configures the maximum amount of seconds to wait before giving up on requests.
	TimeoutSeconds *int `pulumi:"timeoutSeconds"`
	// TLS configures TLS communication with the Authorization Server.
	Tls *AccessControlPolicySpecOAuthIntroClientConfigTls `pulumi:"tls"`
	// TokenTypeHint is a hint to pass to the Authorization Server.
	// See https://tools.ietf.org/html/rfc7662#section-2.1 for more information.
	TokenTypeHint *string `pulumi:"tokenTypeHint"`
	// URL of the Authorization Server.
	Url string `pulumi:"url"`
}

// Defaults sets the appropriate defaults for AccessControlPolicySpecOAuthIntroClientConfig
func (val *AccessControlPolicySpecOAuthIntroClientConfig) Defaults() *AccessControlPolicySpecOAuthIntroClientConfig {
	if val == nil {
		return nil
	}
	tmp := *val
	if tmp.MaxRetries == nil {
		maxRetries_ := 3
		tmp.MaxRetries = &maxRetries_
	}
	if tmp.TimeoutSeconds == nil {
		timeoutSeconds_ := 5
		tmp.TimeoutSeconds = &timeoutSeconds_
	}
	return &tmp
}

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

	ToAccessControlPolicySpecOAuthIntroClientConfigOutput() AccessControlPolicySpecOAuthIntroClientConfigOutput
	ToAccessControlPolicySpecOAuthIntroClientConfigOutputWithContext(context.Context) AccessControlPolicySpecOAuthIntroClientConfigOutput
}

// AccessControlOAuthIntroClientConfig configures the OAuth 2.0 client for issuing token introspection requests.
type AccessControlPolicySpecOAuthIntroClientConfigArgs struct {
	// Headers to set when sending requests to the Authorization Server.
	Headers pulumi.StringMapInput `pulumi:"headers"`
	// MaxRetries defines the number of retries for introspection requests.
	MaxRetries pulumi.IntPtrInput `pulumi:"maxRetries"`
	// TimeoutSeconds configures the maximum amount of seconds to wait before giving up on requests.
	TimeoutSeconds pulumi.IntPtrInput `pulumi:"timeoutSeconds"`
	// TLS configures TLS communication with the Authorization Server.
	Tls AccessControlPolicySpecOAuthIntroClientConfigTlsPtrInput `pulumi:"tls"`
	// TokenTypeHint is a hint to pass to the Authorization Server.
	// See https://tools.ietf.org/html/rfc7662#section-2.1 for more information.
	TokenTypeHint pulumi.StringPtrInput `pulumi:"tokenTypeHint"`
	// URL of the Authorization Server.
	Url pulumi.StringInput `pulumi:"url"`
}

// Defaults sets the appropriate defaults for AccessControlPolicySpecOAuthIntroClientConfigArgs
func (val *AccessControlPolicySpecOAuthIntroClientConfigArgs) Defaults() *AccessControlPolicySpecOAuthIntroClientConfigArgs {
	if val == nil {
		return nil
	}
	tmp := *val
	if tmp.MaxRetries == nil {
		tmp.MaxRetries = pulumi.IntPtr(3)
	}
	if tmp.TimeoutSeconds == nil {
		tmp.TimeoutSeconds = pulumi.IntPtr(5)
	}
	return &tmp
}
func (AccessControlPolicySpecOAuthIntroClientConfigArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecOAuthIntroClientConfig)(nil)).Elem()
}

func (i AccessControlPolicySpecOAuthIntroClientConfigArgs) ToAccessControlPolicySpecOAuthIntroClientConfigOutput() AccessControlPolicySpecOAuthIntroClientConfigOutput {
	return i.ToAccessControlPolicySpecOAuthIntroClientConfigOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecOAuthIntroClientConfigArgs) ToAccessControlPolicySpecOAuthIntroClientConfigOutputWithContext(ctx context.Context) AccessControlPolicySpecOAuthIntroClientConfigOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOAuthIntroClientConfigOutput)
}

func (i AccessControlPolicySpecOAuthIntroClientConfigArgs) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecOAuthIntroClientConfig] {
	return pulumix.Output[AccessControlPolicySpecOAuthIntroClientConfig]{
		OutputState: i.ToAccessControlPolicySpecOAuthIntroClientConfigOutputWithContext(ctx).OutputState,
	}
}

func (i AccessControlPolicySpecOAuthIntroClientConfigArgs) ToAccessControlPolicySpecOAuthIntroClientConfigPtrOutput() AccessControlPolicySpecOAuthIntroClientConfigPtrOutput {
	return i.ToAccessControlPolicySpecOAuthIntroClientConfigPtrOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecOAuthIntroClientConfigArgs) ToAccessControlPolicySpecOAuthIntroClientConfigPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOAuthIntroClientConfigPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOAuthIntroClientConfigOutput).ToAccessControlPolicySpecOAuthIntroClientConfigPtrOutputWithContext(ctx)
}

// AccessControlPolicySpecOAuthIntroClientConfigPtrInput is an input type that accepts AccessControlPolicySpecOAuthIntroClientConfigArgs, AccessControlPolicySpecOAuthIntroClientConfigPtr and AccessControlPolicySpecOAuthIntroClientConfigPtrOutput values.
// You can construct a concrete instance of `AccessControlPolicySpecOAuthIntroClientConfigPtrInput` via:
//
//	        AccessControlPolicySpecOAuthIntroClientConfigArgs{...}
//
//	or:
//
//	        nil
type AccessControlPolicySpecOAuthIntroClientConfigPtrInput interface {
	pulumi.Input

	ToAccessControlPolicySpecOAuthIntroClientConfigPtrOutput() AccessControlPolicySpecOAuthIntroClientConfigPtrOutput
	ToAccessControlPolicySpecOAuthIntroClientConfigPtrOutputWithContext(context.Context) AccessControlPolicySpecOAuthIntroClientConfigPtrOutput
}

type accessControlPolicySpecOAuthIntroClientConfigPtrType AccessControlPolicySpecOAuthIntroClientConfigArgs

func AccessControlPolicySpecOAuthIntroClientConfigPtr(v *AccessControlPolicySpecOAuthIntroClientConfigArgs) AccessControlPolicySpecOAuthIntroClientConfigPtrInput {
	return (*accessControlPolicySpecOAuthIntroClientConfigPtrType)(v)
}

func (*accessControlPolicySpecOAuthIntroClientConfigPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecOAuthIntroClientConfig)(nil)).Elem()
}

func (i *accessControlPolicySpecOAuthIntroClientConfigPtrType) ToAccessControlPolicySpecOAuthIntroClientConfigPtrOutput() AccessControlPolicySpecOAuthIntroClientConfigPtrOutput {
	return i.ToAccessControlPolicySpecOAuthIntroClientConfigPtrOutputWithContext(context.Background())
}

func (i *accessControlPolicySpecOAuthIntroClientConfigPtrType) ToAccessControlPolicySpecOAuthIntroClientConfigPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOAuthIntroClientConfigPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOAuthIntroClientConfigPtrOutput)
}

func (i *accessControlPolicySpecOAuthIntroClientConfigPtrType) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecOAuthIntroClientConfig] {
	return pulumix.Output[*AccessControlPolicySpecOAuthIntroClientConfig]{
		OutputState: i.ToAccessControlPolicySpecOAuthIntroClientConfigPtrOutputWithContext(ctx).OutputState,
	}
}

// AccessControlOAuthIntroClientConfig configures the OAuth 2.0 client for issuing token introspection requests.
type AccessControlPolicySpecOAuthIntroClientConfigOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecOAuthIntroClientConfigOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecOAuthIntroClientConfig)(nil)).Elem()
}

func (o AccessControlPolicySpecOAuthIntroClientConfigOutput) ToAccessControlPolicySpecOAuthIntroClientConfigOutput() AccessControlPolicySpecOAuthIntroClientConfigOutput {
	return o
}

func (o AccessControlPolicySpecOAuthIntroClientConfigOutput) ToAccessControlPolicySpecOAuthIntroClientConfigOutputWithContext(ctx context.Context) AccessControlPolicySpecOAuthIntroClientConfigOutput {
	return o
}

func (o AccessControlPolicySpecOAuthIntroClientConfigOutput) ToAccessControlPolicySpecOAuthIntroClientConfigPtrOutput() AccessControlPolicySpecOAuthIntroClientConfigPtrOutput {
	return o.ToAccessControlPolicySpecOAuthIntroClientConfigPtrOutputWithContext(context.Background())
}

func (o AccessControlPolicySpecOAuthIntroClientConfigOutput) ToAccessControlPolicySpecOAuthIntroClientConfigPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOAuthIntroClientConfigPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v AccessControlPolicySpecOAuthIntroClientConfig) *AccessControlPolicySpecOAuthIntroClientConfig {
		return &v
	}).(AccessControlPolicySpecOAuthIntroClientConfigPtrOutput)
}

func (o AccessControlPolicySpecOAuthIntroClientConfigOutput) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecOAuthIntroClientConfig] {
	return pulumix.Output[AccessControlPolicySpecOAuthIntroClientConfig]{
		OutputState: o.OutputState,
	}
}

// Headers to set when sending requests to the Authorization Server.
func (o AccessControlPolicySpecOAuthIntroClientConfigOutput) Headers() pulumi.StringMapOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOAuthIntroClientConfig) map[string]string { return v.Headers }).(pulumi.StringMapOutput)
}

// MaxRetries defines the number of retries for introspection requests.
func (o AccessControlPolicySpecOAuthIntroClientConfigOutput) MaxRetries() pulumi.IntPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOAuthIntroClientConfig) *int { return v.MaxRetries }).(pulumi.IntPtrOutput)
}

// TimeoutSeconds configures the maximum amount of seconds to wait before giving up on requests.
func (o AccessControlPolicySpecOAuthIntroClientConfigOutput) TimeoutSeconds() pulumi.IntPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOAuthIntroClientConfig) *int { return v.TimeoutSeconds }).(pulumi.IntPtrOutput)
}

// TLS configures TLS communication with the Authorization Server.
func (o AccessControlPolicySpecOAuthIntroClientConfigOutput) Tls() AccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOAuthIntroClientConfig) *AccessControlPolicySpecOAuthIntroClientConfigTls {
		return v.Tls
	}).(AccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput)
}

// TokenTypeHint is a hint to pass to the Authorization Server.
// See https://tools.ietf.org/html/rfc7662#section-2.1 for more information.
func (o AccessControlPolicySpecOAuthIntroClientConfigOutput) TokenTypeHint() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOAuthIntroClientConfig) *string { return v.TokenTypeHint }).(pulumi.StringPtrOutput)
}

// URL of the Authorization Server.
func (o AccessControlPolicySpecOAuthIntroClientConfigOutput) Url() pulumi.StringOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOAuthIntroClientConfig) string { return v.Url }).(pulumi.StringOutput)
}

type AccessControlPolicySpecOAuthIntroClientConfigPtrOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecOAuthIntroClientConfigPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecOAuthIntroClientConfig)(nil)).Elem()
}

func (o AccessControlPolicySpecOAuthIntroClientConfigPtrOutput) ToAccessControlPolicySpecOAuthIntroClientConfigPtrOutput() AccessControlPolicySpecOAuthIntroClientConfigPtrOutput {
	return o
}

func (o AccessControlPolicySpecOAuthIntroClientConfigPtrOutput) ToAccessControlPolicySpecOAuthIntroClientConfigPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOAuthIntroClientConfigPtrOutput {
	return o
}

func (o AccessControlPolicySpecOAuthIntroClientConfigPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecOAuthIntroClientConfig] {
	return pulumix.Output[*AccessControlPolicySpecOAuthIntroClientConfig]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicySpecOAuthIntroClientConfigPtrOutput) Elem() AccessControlPolicySpecOAuthIntroClientConfigOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOAuthIntroClientConfig) AccessControlPolicySpecOAuthIntroClientConfig {
		if v != nil {
			return *v
		}
		var ret AccessControlPolicySpecOAuthIntroClientConfig
		return ret
	}).(AccessControlPolicySpecOAuthIntroClientConfigOutput)
}

// Headers to set when sending requests to the Authorization Server.
func (o AccessControlPolicySpecOAuthIntroClientConfigPtrOutput) Headers() pulumi.StringMapOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOAuthIntroClientConfig) map[string]string {
		if v == nil {
			return nil
		}
		return v.Headers
	}).(pulumi.StringMapOutput)
}

// MaxRetries defines the number of retries for introspection requests.
func (o AccessControlPolicySpecOAuthIntroClientConfigPtrOutput) MaxRetries() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOAuthIntroClientConfig) *int {
		if v == nil {
			return nil
		}
		return v.MaxRetries
	}).(pulumi.IntPtrOutput)
}

// TimeoutSeconds configures the maximum amount of seconds to wait before giving up on requests.
func (o AccessControlPolicySpecOAuthIntroClientConfigPtrOutput) TimeoutSeconds() pulumi.IntPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOAuthIntroClientConfig) *int {
		if v == nil {
			return nil
		}
		return v.TimeoutSeconds
	}).(pulumi.IntPtrOutput)
}

// TLS configures TLS communication with the Authorization Server.
func (o AccessControlPolicySpecOAuthIntroClientConfigPtrOutput) Tls() AccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOAuthIntroClientConfig) *AccessControlPolicySpecOAuthIntroClientConfigTls {
		if v == nil {
			return nil
		}
		return v.Tls
	}).(AccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput)
}

// TokenTypeHint is a hint to pass to the Authorization Server.
// See https://tools.ietf.org/html/rfc7662#section-2.1 for more information.
func (o AccessControlPolicySpecOAuthIntroClientConfigPtrOutput) TokenTypeHint() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOAuthIntroClientConfig) *string {
		if v == nil {
			return nil
		}
		return v.TokenTypeHint
	}).(pulumi.StringPtrOutput)
}

// URL of the Authorization Server.
func (o AccessControlPolicySpecOAuthIntroClientConfigPtrOutput) Url() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOAuthIntroClientConfig) *string {
		if v == nil {
			return nil
		}
		return &v.Url
	}).(pulumi.StringPtrOutput)
}

// Headers to set when sending requests to the Authorization Server.
type AccessControlPolicySpecOAuthIntroClientConfigHeaders struct {
}

// TLS configures TLS communication with the Authorization Server.
type AccessControlPolicySpecOAuthIntroClientConfigTls struct {
	// CA sets the CA bundle used to sign the Authorization Server certificate.
	Ca *string `pulumi:"ca"`
	// InsecureSkipVerify skips the Authorization Server certificate validation.
	// For testing purposes only, do not use in production.
	InsecureSkipVerify *bool `pulumi:"insecureSkipVerify"`
}

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

	ToAccessControlPolicySpecOAuthIntroClientConfigTlsOutput() AccessControlPolicySpecOAuthIntroClientConfigTlsOutput
	ToAccessControlPolicySpecOAuthIntroClientConfigTlsOutputWithContext(context.Context) AccessControlPolicySpecOAuthIntroClientConfigTlsOutput
}

// TLS configures TLS communication with the Authorization Server.
type AccessControlPolicySpecOAuthIntroClientConfigTlsArgs struct {
	// CA sets the CA bundle used to sign the Authorization Server certificate.
	Ca pulumi.StringPtrInput `pulumi:"ca"`
	// InsecureSkipVerify skips the Authorization Server certificate validation.
	// For testing purposes only, do not use in production.
	InsecureSkipVerify pulumi.BoolPtrInput `pulumi:"insecureSkipVerify"`
}

func (AccessControlPolicySpecOAuthIntroClientConfigTlsArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecOAuthIntroClientConfigTls)(nil)).Elem()
}

func (i AccessControlPolicySpecOAuthIntroClientConfigTlsArgs) ToAccessControlPolicySpecOAuthIntroClientConfigTlsOutput() AccessControlPolicySpecOAuthIntroClientConfigTlsOutput {
	return i.ToAccessControlPolicySpecOAuthIntroClientConfigTlsOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecOAuthIntroClientConfigTlsArgs) ToAccessControlPolicySpecOAuthIntroClientConfigTlsOutputWithContext(ctx context.Context) AccessControlPolicySpecOAuthIntroClientConfigTlsOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOAuthIntroClientConfigTlsOutput)
}

func (i AccessControlPolicySpecOAuthIntroClientConfigTlsArgs) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecOAuthIntroClientConfigTls] {
	return pulumix.Output[AccessControlPolicySpecOAuthIntroClientConfigTls]{
		OutputState: i.ToAccessControlPolicySpecOAuthIntroClientConfigTlsOutputWithContext(ctx).OutputState,
	}
}

func (i AccessControlPolicySpecOAuthIntroClientConfigTlsArgs) ToAccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput() AccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput {
	return i.ToAccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecOAuthIntroClientConfigTlsArgs) ToAccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOAuthIntroClientConfigTlsOutput).ToAccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutputWithContext(ctx)
}

// AccessControlPolicySpecOAuthIntroClientConfigTlsPtrInput is an input type that accepts AccessControlPolicySpecOAuthIntroClientConfigTlsArgs, AccessControlPolicySpecOAuthIntroClientConfigTlsPtr and AccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput values.
// You can construct a concrete instance of `AccessControlPolicySpecOAuthIntroClientConfigTlsPtrInput` via:
//
//	        AccessControlPolicySpecOAuthIntroClientConfigTlsArgs{...}
//
//	or:
//
//	        nil
type AccessControlPolicySpecOAuthIntroClientConfigTlsPtrInput interface {
	pulumi.Input

	ToAccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput() AccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput
	ToAccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutputWithContext(context.Context) AccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput
}

type accessControlPolicySpecOAuthIntroClientConfigTlsPtrType AccessControlPolicySpecOAuthIntroClientConfigTlsArgs

func AccessControlPolicySpecOAuthIntroClientConfigTlsPtr(v *AccessControlPolicySpecOAuthIntroClientConfigTlsArgs) AccessControlPolicySpecOAuthIntroClientConfigTlsPtrInput {
	return (*accessControlPolicySpecOAuthIntroClientConfigTlsPtrType)(v)
}

func (*accessControlPolicySpecOAuthIntroClientConfigTlsPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecOAuthIntroClientConfigTls)(nil)).Elem()
}

func (i *accessControlPolicySpecOAuthIntroClientConfigTlsPtrType) ToAccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput() AccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput {
	return i.ToAccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutputWithContext(context.Background())
}

func (i *accessControlPolicySpecOAuthIntroClientConfigTlsPtrType) ToAccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput)
}

func (i *accessControlPolicySpecOAuthIntroClientConfigTlsPtrType) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecOAuthIntroClientConfigTls] {
	return pulumix.Output[*AccessControlPolicySpecOAuthIntroClientConfigTls]{
		OutputState: i.ToAccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutputWithContext(ctx).OutputState,
	}
}

// TLS configures TLS communication with the Authorization Server.
type AccessControlPolicySpecOAuthIntroClientConfigTlsOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecOAuthIntroClientConfigTlsOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecOAuthIntroClientConfigTls)(nil)).Elem()
}

func (o AccessControlPolicySpecOAuthIntroClientConfigTlsOutput) ToAccessControlPolicySpecOAuthIntroClientConfigTlsOutput() AccessControlPolicySpecOAuthIntroClientConfigTlsOutput {
	return o
}

func (o AccessControlPolicySpecOAuthIntroClientConfigTlsOutput) ToAccessControlPolicySpecOAuthIntroClientConfigTlsOutputWithContext(ctx context.Context) AccessControlPolicySpecOAuthIntroClientConfigTlsOutput {
	return o
}

func (o AccessControlPolicySpecOAuthIntroClientConfigTlsOutput) ToAccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput() AccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput {
	return o.ToAccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutputWithContext(context.Background())
}

func (o AccessControlPolicySpecOAuthIntroClientConfigTlsOutput) ToAccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v AccessControlPolicySpecOAuthIntroClientConfigTls) *AccessControlPolicySpecOAuthIntroClientConfigTls {
		return &v
	}).(AccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput)
}

func (o AccessControlPolicySpecOAuthIntroClientConfigTlsOutput) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecOAuthIntroClientConfigTls] {
	return pulumix.Output[AccessControlPolicySpecOAuthIntroClientConfigTls]{
		OutputState: o.OutputState,
	}
}

// CA sets the CA bundle used to sign the Authorization Server certificate.
func (o AccessControlPolicySpecOAuthIntroClientConfigTlsOutput) Ca() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOAuthIntroClientConfigTls) *string { return v.Ca }).(pulumi.StringPtrOutput)
}

// InsecureSkipVerify skips the Authorization Server certificate validation.
// For testing purposes only, do not use in production.
func (o AccessControlPolicySpecOAuthIntroClientConfigTlsOutput) InsecureSkipVerify() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOAuthIntroClientConfigTls) *bool { return v.InsecureSkipVerify }).(pulumi.BoolPtrOutput)
}

type AccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecOAuthIntroClientConfigTls)(nil)).Elem()
}

func (o AccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput) ToAccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput() AccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput {
	return o
}

func (o AccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput) ToAccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput {
	return o
}

func (o AccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecOAuthIntroClientConfigTls] {
	return pulumix.Output[*AccessControlPolicySpecOAuthIntroClientConfigTls]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput) Elem() AccessControlPolicySpecOAuthIntroClientConfigTlsOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOAuthIntroClientConfigTls) AccessControlPolicySpecOAuthIntroClientConfigTls {
		if v != nil {
			return *v
		}
		var ret AccessControlPolicySpecOAuthIntroClientConfigTls
		return ret
	}).(AccessControlPolicySpecOAuthIntroClientConfigTlsOutput)
}

// CA sets the CA bundle used to sign the Authorization Server certificate.
func (o AccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput) Ca() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOAuthIntroClientConfigTls) *string {
		if v == nil {
			return nil
		}
		return v.Ca
	}).(pulumi.StringPtrOutput)
}

// InsecureSkipVerify skips the Authorization Server certificate validation.
// For testing purposes only, do not use in production.
func (o AccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput) InsecureSkipVerify() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOAuthIntroClientConfigTls) *bool {
		if v == nil {
			return nil
		}
		return v.InsecureSkipVerify
	}).(pulumi.BoolPtrOutput)
}

type AccessControlPolicySpecOAuthIntroForwardHeaders struct {
}

// TokenSource describes how to extract tokens from HTTP requests.
// If multiple sources are set, the order is the following: header > query > cookie.
type AccessControlPolicySpecOAuthIntroTokenSource struct {
	// Cookie is the name of a cookie.
	Cookie *string `pulumi:"cookie"`
	// Header is the name of a header.
	Header *string `pulumi:"header"`
	// HeaderAuthScheme sets an optional auth scheme when Header is set to "Authorization".
	// If set, this scheme is removed from the token, and all requests not including it are dropped.
	HeaderAuthScheme *string `pulumi:"headerAuthScheme"`
	// Query is the name of a query parameter.
	Query *string `pulumi:"query"`
}

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

	ToAccessControlPolicySpecOAuthIntroTokenSourceOutput() AccessControlPolicySpecOAuthIntroTokenSourceOutput
	ToAccessControlPolicySpecOAuthIntroTokenSourceOutputWithContext(context.Context) AccessControlPolicySpecOAuthIntroTokenSourceOutput
}

// TokenSource describes how to extract tokens from HTTP requests.
// If multiple sources are set, the order is the following: header > query > cookie.
type AccessControlPolicySpecOAuthIntroTokenSourceArgs struct {
	// Cookie is the name of a cookie.
	Cookie pulumi.StringPtrInput `pulumi:"cookie"`
	// Header is the name of a header.
	Header pulumi.StringPtrInput `pulumi:"header"`
	// HeaderAuthScheme sets an optional auth scheme when Header is set to "Authorization".
	// If set, this scheme is removed from the token, and all requests not including it are dropped.
	HeaderAuthScheme pulumi.StringPtrInput `pulumi:"headerAuthScheme"`
	// Query is the name of a query parameter.
	Query pulumi.StringPtrInput `pulumi:"query"`
}

func (AccessControlPolicySpecOAuthIntroTokenSourceArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecOAuthIntroTokenSource)(nil)).Elem()
}

func (i AccessControlPolicySpecOAuthIntroTokenSourceArgs) ToAccessControlPolicySpecOAuthIntroTokenSourceOutput() AccessControlPolicySpecOAuthIntroTokenSourceOutput {
	return i.ToAccessControlPolicySpecOAuthIntroTokenSourceOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecOAuthIntroTokenSourceArgs) ToAccessControlPolicySpecOAuthIntroTokenSourceOutputWithContext(ctx context.Context) AccessControlPolicySpecOAuthIntroTokenSourceOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOAuthIntroTokenSourceOutput)
}

func (i AccessControlPolicySpecOAuthIntroTokenSourceArgs) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecOAuthIntroTokenSource] {
	return pulumix.Output[AccessControlPolicySpecOAuthIntroTokenSource]{
		OutputState: i.ToAccessControlPolicySpecOAuthIntroTokenSourceOutputWithContext(ctx).OutputState,
	}
}

func (i AccessControlPolicySpecOAuthIntroTokenSourceArgs) ToAccessControlPolicySpecOAuthIntroTokenSourcePtrOutput() AccessControlPolicySpecOAuthIntroTokenSourcePtrOutput {
	return i.ToAccessControlPolicySpecOAuthIntroTokenSourcePtrOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecOAuthIntroTokenSourceArgs) ToAccessControlPolicySpecOAuthIntroTokenSourcePtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOAuthIntroTokenSourcePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOAuthIntroTokenSourceOutput).ToAccessControlPolicySpecOAuthIntroTokenSourcePtrOutputWithContext(ctx)
}

// AccessControlPolicySpecOAuthIntroTokenSourcePtrInput is an input type that accepts AccessControlPolicySpecOAuthIntroTokenSourceArgs, AccessControlPolicySpecOAuthIntroTokenSourcePtr and AccessControlPolicySpecOAuthIntroTokenSourcePtrOutput values.
// You can construct a concrete instance of `AccessControlPolicySpecOAuthIntroTokenSourcePtrInput` via:
//
//	        AccessControlPolicySpecOAuthIntroTokenSourceArgs{...}
//
//	or:
//
//	        nil
type AccessControlPolicySpecOAuthIntroTokenSourcePtrInput interface {
	pulumi.Input

	ToAccessControlPolicySpecOAuthIntroTokenSourcePtrOutput() AccessControlPolicySpecOAuthIntroTokenSourcePtrOutput
	ToAccessControlPolicySpecOAuthIntroTokenSourcePtrOutputWithContext(context.Context) AccessControlPolicySpecOAuthIntroTokenSourcePtrOutput
}

type accessControlPolicySpecOAuthIntroTokenSourcePtrType AccessControlPolicySpecOAuthIntroTokenSourceArgs

func AccessControlPolicySpecOAuthIntroTokenSourcePtr(v *AccessControlPolicySpecOAuthIntroTokenSourceArgs) AccessControlPolicySpecOAuthIntroTokenSourcePtrInput {
	return (*accessControlPolicySpecOAuthIntroTokenSourcePtrType)(v)
}

func (*accessControlPolicySpecOAuthIntroTokenSourcePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecOAuthIntroTokenSource)(nil)).Elem()
}

func (i *accessControlPolicySpecOAuthIntroTokenSourcePtrType) ToAccessControlPolicySpecOAuthIntroTokenSourcePtrOutput() AccessControlPolicySpecOAuthIntroTokenSourcePtrOutput {
	return i.ToAccessControlPolicySpecOAuthIntroTokenSourcePtrOutputWithContext(context.Background())
}

func (i *accessControlPolicySpecOAuthIntroTokenSourcePtrType) ToAccessControlPolicySpecOAuthIntroTokenSourcePtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOAuthIntroTokenSourcePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOAuthIntroTokenSourcePtrOutput)
}

func (i *accessControlPolicySpecOAuthIntroTokenSourcePtrType) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecOAuthIntroTokenSource] {
	return pulumix.Output[*AccessControlPolicySpecOAuthIntroTokenSource]{
		OutputState: i.ToAccessControlPolicySpecOAuthIntroTokenSourcePtrOutputWithContext(ctx).OutputState,
	}
}

// TokenSource describes how to extract tokens from HTTP requests.
// If multiple sources are set, the order is the following: header > query > cookie.
type AccessControlPolicySpecOAuthIntroTokenSourceOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecOAuthIntroTokenSourceOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecOAuthIntroTokenSource)(nil)).Elem()
}

func (o AccessControlPolicySpecOAuthIntroTokenSourceOutput) ToAccessControlPolicySpecOAuthIntroTokenSourceOutput() AccessControlPolicySpecOAuthIntroTokenSourceOutput {
	return o
}

func (o AccessControlPolicySpecOAuthIntroTokenSourceOutput) ToAccessControlPolicySpecOAuthIntroTokenSourceOutputWithContext(ctx context.Context) AccessControlPolicySpecOAuthIntroTokenSourceOutput {
	return o
}

func (o AccessControlPolicySpecOAuthIntroTokenSourceOutput) ToAccessControlPolicySpecOAuthIntroTokenSourcePtrOutput() AccessControlPolicySpecOAuthIntroTokenSourcePtrOutput {
	return o.ToAccessControlPolicySpecOAuthIntroTokenSourcePtrOutputWithContext(context.Background())
}

func (o AccessControlPolicySpecOAuthIntroTokenSourceOutput) ToAccessControlPolicySpecOAuthIntroTokenSourcePtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOAuthIntroTokenSourcePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v AccessControlPolicySpecOAuthIntroTokenSource) *AccessControlPolicySpecOAuthIntroTokenSource {
		return &v
	}).(AccessControlPolicySpecOAuthIntroTokenSourcePtrOutput)
}

func (o AccessControlPolicySpecOAuthIntroTokenSourceOutput) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecOAuthIntroTokenSource] {
	return pulumix.Output[AccessControlPolicySpecOAuthIntroTokenSource]{
		OutputState: o.OutputState,
	}
}

// Cookie is the name of a cookie.
func (o AccessControlPolicySpecOAuthIntroTokenSourceOutput) Cookie() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOAuthIntroTokenSource) *string { return v.Cookie }).(pulumi.StringPtrOutput)
}

// Header is the name of a header.
func (o AccessControlPolicySpecOAuthIntroTokenSourceOutput) Header() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOAuthIntroTokenSource) *string { return v.Header }).(pulumi.StringPtrOutput)
}

// HeaderAuthScheme sets an optional auth scheme when Header is set to "Authorization".
// If set, this scheme is removed from the token, and all requests not including it are dropped.
func (o AccessControlPolicySpecOAuthIntroTokenSourceOutput) HeaderAuthScheme() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOAuthIntroTokenSource) *string { return v.HeaderAuthScheme }).(pulumi.StringPtrOutput)
}

// Query is the name of a query parameter.
func (o AccessControlPolicySpecOAuthIntroTokenSourceOutput) Query() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOAuthIntroTokenSource) *string { return v.Query }).(pulumi.StringPtrOutput)
}

type AccessControlPolicySpecOAuthIntroTokenSourcePtrOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecOAuthIntroTokenSourcePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecOAuthIntroTokenSource)(nil)).Elem()
}

func (o AccessControlPolicySpecOAuthIntroTokenSourcePtrOutput) ToAccessControlPolicySpecOAuthIntroTokenSourcePtrOutput() AccessControlPolicySpecOAuthIntroTokenSourcePtrOutput {
	return o
}

func (o AccessControlPolicySpecOAuthIntroTokenSourcePtrOutput) ToAccessControlPolicySpecOAuthIntroTokenSourcePtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOAuthIntroTokenSourcePtrOutput {
	return o
}

func (o AccessControlPolicySpecOAuthIntroTokenSourcePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecOAuthIntroTokenSource] {
	return pulumix.Output[*AccessControlPolicySpecOAuthIntroTokenSource]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicySpecOAuthIntroTokenSourcePtrOutput) Elem() AccessControlPolicySpecOAuthIntroTokenSourceOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOAuthIntroTokenSource) AccessControlPolicySpecOAuthIntroTokenSource {
		if v != nil {
			return *v
		}
		var ret AccessControlPolicySpecOAuthIntroTokenSource
		return ret
	}).(AccessControlPolicySpecOAuthIntroTokenSourceOutput)
}

// Cookie is the name of a cookie.
func (o AccessControlPolicySpecOAuthIntroTokenSourcePtrOutput) Cookie() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOAuthIntroTokenSource) *string {
		if v == nil {
			return nil
		}
		return v.Cookie
	}).(pulumi.StringPtrOutput)
}

// Header is the name of a header.
func (o AccessControlPolicySpecOAuthIntroTokenSourcePtrOutput) Header() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOAuthIntroTokenSource) *string {
		if v == nil {
			return nil
		}
		return v.Header
	}).(pulumi.StringPtrOutput)
}

// HeaderAuthScheme sets an optional auth scheme when Header is set to "Authorization".
// If set, this scheme is removed from the token, and all requests not including it are dropped.
func (o AccessControlPolicySpecOAuthIntroTokenSourcePtrOutput) HeaderAuthScheme() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOAuthIntroTokenSource) *string {
		if v == nil {
			return nil
		}
		return v.HeaderAuthScheme
	}).(pulumi.StringPtrOutput)
}

// Query is the name of a query parameter.
func (o AccessControlPolicySpecOAuthIntroTokenSourcePtrOutput) Query() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOAuthIntroTokenSource) *string {
		if v == nil {
			return nil
		}
		return v.Query
	}).(pulumi.StringPtrOutput)
}

// AccessControlPolicyOIDC holds the OIDC authentication configuration.
type AccessControlPolicySpecOidc struct {
	AuthParams                  map[string]string `pulumi:"authParams"`
	Claims                      *string           `pulumi:"claims"`
	ClientId                    *string           `pulumi:"clientId"`
	DisableAuthRedirectionPaths []string          `pulumi:"disableAuthRedirectionPaths"`
	ForwardHeaders              map[string]string `pulumi:"forwardHeaders"`
	Issuer                      *string           `pulumi:"issuer"`
	LogoutUrl                   *string           `pulumi:"logoutUrl"`
	RedirectUrl                 *string           `pulumi:"redirectUrl"`
	Scopes                      []string          `pulumi:"scopes"`
	// SecretReference represents a Secret Reference. It has enough information to retrieve secret
	// in any namespace
	Secret *AccessControlPolicySpecOidcSecret `pulumi:"secret"`
	// Session holds session configuration.
	Session *AccessControlPolicySpecOidcSession `pulumi:"session"`
	// StateCookie holds state cookie configuration.
	StateCookie *AccessControlPolicySpecOidcStateCookie `pulumi:"stateCookie"`
}

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

	ToAccessControlPolicySpecOidcOutput() AccessControlPolicySpecOidcOutput
	ToAccessControlPolicySpecOidcOutputWithContext(context.Context) AccessControlPolicySpecOidcOutput
}

// AccessControlPolicyOIDC holds the OIDC authentication configuration.
type AccessControlPolicySpecOidcArgs struct {
	AuthParams                  pulumi.StringMapInput   `pulumi:"authParams"`
	Claims                      pulumi.StringPtrInput   `pulumi:"claims"`
	ClientId                    pulumi.StringPtrInput   `pulumi:"clientId"`
	DisableAuthRedirectionPaths pulumi.StringArrayInput `pulumi:"disableAuthRedirectionPaths"`
	ForwardHeaders              pulumi.StringMapInput   `pulumi:"forwardHeaders"`
	Issuer                      pulumi.StringPtrInput   `pulumi:"issuer"`
	LogoutUrl                   pulumi.StringPtrInput   `pulumi:"logoutUrl"`
	RedirectUrl                 pulumi.StringPtrInput   `pulumi:"redirectUrl"`
	Scopes                      pulumi.StringArrayInput `pulumi:"scopes"`
	// SecretReference represents a Secret Reference. It has enough information to retrieve secret
	// in any namespace
	Secret AccessControlPolicySpecOidcSecretPtrInput `pulumi:"secret"`
	// Session holds session configuration.
	Session AccessControlPolicySpecOidcSessionPtrInput `pulumi:"session"`
	// StateCookie holds state cookie configuration.
	StateCookie AccessControlPolicySpecOidcStateCookiePtrInput `pulumi:"stateCookie"`
}

func (AccessControlPolicySpecOidcArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecOidc)(nil)).Elem()
}

func (i AccessControlPolicySpecOidcArgs) ToAccessControlPolicySpecOidcOutput() AccessControlPolicySpecOidcOutput {
	return i.ToAccessControlPolicySpecOidcOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecOidcArgs) ToAccessControlPolicySpecOidcOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOidcOutput)
}

func (i AccessControlPolicySpecOidcArgs) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecOidc] {
	return pulumix.Output[AccessControlPolicySpecOidc]{
		OutputState: i.ToAccessControlPolicySpecOidcOutputWithContext(ctx).OutputState,
	}
}

func (i AccessControlPolicySpecOidcArgs) ToAccessControlPolicySpecOidcPtrOutput() AccessControlPolicySpecOidcPtrOutput {
	return i.ToAccessControlPolicySpecOidcPtrOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecOidcArgs) ToAccessControlPolicySpecOidcPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOidcOutput).ToAccessControlPolicySpecOidcPtrOutputWithContext(ctx)
}

// AccessControlPolicySpecOidcPtrInput is an input type that accepts AccessControlPolicySpecOidcArgs, AccessControlPolicySpecOidcPtr and AccessControlPolicySpecOidcPtrOutput values.
// You can construct a concrete instance of `AccessControlPolicySpecOidcPtrInput` via:
//
//	        AccessControlPolicySpecOidcArgs{...}
//
//	or:
//
//	        nil
type AccessControlPolicySpecOidcPtrInput interface {
	pulumi.Input

	ToAccessControlPolicySpecOidcPtrOutput() AccessControlPolicySpecOidcPtrOutput
	ToAccessControlPolicySpecOidcPtrOutputWithContext(context.Context) AccessControlPolicySpecOidcPtrOutput
}

type accessControlPolicySpecOidcPtrType AccessControlPolicySpecOidcArgs

func AccessControlPolicySpecOidcPtr(v *AccessControlPolicySpecOidcArgs) AccessControlPolicySpecOidcPtrInput {
	return (*accessControlPolicySpecOidcPtrType)(v)
}

func (*accessControlPolicySpecOidcPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecOidc)(nil)).Elem()
}

func (i *accessControlPolicySpecOidcPtrType) ToAccessControlPolicySpecOidcPtrOutput() AccessControlPolicySpecOidcPtrOutput {
	return i.ToAccessControlPolicySpecOidcPtrOutputWithContext(context.Background())
}

func (i *accessControlPolicySpecOidcPtrType) ToAccessControlPolicySpecOidcPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOidcPtrOutput)
}

func (i *accessControlPolicySpecOidcPtrType) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecOidc] {
	return pulumix.Output[*AccessControlPolicySpecOidc]{
		OutputState: i.ToAccessControlPolicySpecOidcPtrOutputWithContext(ctx).OutputState,
	}
}

// AccessControlPolicyOIDC holds the OIDC authentication configuration.
type AccessControlPolicySpecOidcOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecOidcOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecOidc)(nil)).Elem()
}

func (o AccessControlPolicySpecOidcOutput) ToAccessControlPolicySpecOidcOutput() AccessControlPolicySpecOidcOutput {
	return o
}

func (o AccessControlPolicySpecOidcOutput) ToAccessControlPolicySpecOidcOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcOutput {
	return o
}

func (o AccessControlPolicySpecOidcOutput) ToAccessControlPolicySpecOidcPtrOutput() AccessControlPolicySpecOidcPtrOutput {
	return o.ToAccessControlPolicySpecOidcPtrOutputWithContext(context.Background())
}

func (o AccessControlPolicySpecOidcOutput) ToAccessControlPolicySpecOidcPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v AccessControlPolicySpecOidc) *AccessControlPolicySpecOidc {
		return &v
	}).(AccessControlPolicySpecOidcPtrOutput)
}

func (o AccessControlPolicySpecOidcOutput) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecOidc] {
	return pulumix.Output[AccessControlPolicySpecOidc]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicySpecOidcOutput) AuthParams() pulumi.StringMapOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidc) map[string]string { return v.AuthParams }).(pulumi.StringMapOutput)
}

func (o AccessControlPolicySpecOidcOutput) Claims() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidc) *string { return v.Claims }).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcOutput) ClientId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidc) *string { return v.ClientId }).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcOutput) DisableAuthRedirectionPaths() pulumi.StringArrayOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidc) []string { return v.DisableAuthRedirectionPaths }).(pulumi.StringArrayOutput)
}

func (o AccessControlPolicySpecOidcOutput) ForwardHeaders() pulumi.StringMapOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidc) map[string]string { return v.ForwardHeaders }).(pulumi.StringMapOutput)
}

func (o AccessControlPolicySpecOidcOutput) Issuer() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidc) *string { return v.Issuer }).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcOutput) LogoutUrl() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidc) *string { return v.LogoutUrl }).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcOutput) RedirectUrl() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidc) *string { return v.RedirectUrl }).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcOutput) Scopes() pulumi.StringArrayOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidc) []string { return v.Scopes }).(pulumi.StringArrayOutput)
}

// SecretReference represents a Secret Reference. It has enough information to retrieve secret
// in any namespace
func (o AccessControlPolicySpecOidcOutput) Secret() AccessControlPolicySpecOidcSecretPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidc) *AccessControlPolicySpecOidcSecret { return v.Secret }).(AccessControlPolicySpecOidcSecretPtrOutput)
}

// Session holds session configuration.
func (o AccessControlPolicySpecOidcOutput) Session() AccessControlPolicySpecOidcSessionPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidc) *AccessControlPolicySpecOidcSession { return v.Session }).(AccessControlPolicySpecOidcSessionPtrOutput)
}

// StateCookie holds state cookie configuration.
func (o AccessControlPolicySpecOidcOutput) StateCookie() AccessControlPolicySpecOidcStateCookiePtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidc) *AccessControlPolicySpecOidcStateCookie { return v.StateCookie }).(AccessControlPolicySpecOidcStateCookiePtrOutput)
}

type AccessControlPolicySpecOidcPtrOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecOidcPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecOidc)(nil)).Elem()
}

func (o AccessControlPolicySpecOidcPtrOutput) ToAccessControlPolicySpecOidcPtrOutput() AccessControlPolicySpecOidcPtrOutput {
	return o
}

func (o AccessControlPolicySpecOidcPtrOutput) ToAccessControlPolicySpecOidcPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcPtrOutput {
	return o
}

func (o AccessControlPolicySpecOidcPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecOidc] {
	return pulumix.Output[*AccessControlPolicySpecOidc]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicySpecOidcPtrOutput) Elem() AccessControlPolicySpecOidcOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidc) AccessControlPolicySpecOidc {
		if v != nil {
			return *v
		}
		var ret AccessControlPolicySpecOidc
		return ret
	}).(AccessControlPolicySpecOidcOutput)
}

func (o AccessControlPolicySpecOidcPtrOutput) AuthParams() pulumi.StringMapOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidc) map[string]string {
		if v == nil {
			return nil
		}
		return v.AuthParams
	}).(pulumi.StringMapOutput)
}

func (o AccessControlPolicySpecOidcPtrOutput) Claims() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidc) *string {
		if v == nil {
			return nil
		}
		return v.Claims
	}).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcPtrOutput) ClientId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidc) *string {
		if v == nil {
			return nil
		}
		return v.ClientId
	}).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcPtrOutput) DisableAuthRedirectionPaths() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidc) []string {
		if v == nil {
			return nil
		}
		return v.DisableAuthRedirectionPaths
	}).(pulumi.StringArrayOutput)
}

func (o AccessControlPolicySpecOidcPtrOutput) ForwardHeaders() pulumi.StringMapOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidc) map[string]string {
		if v == nil {
			return nil
		}
		return v.ForwardHeaders
	}).(pulumi.StringMapOutput)
}

func (o AccessControlPolicySpecOidcPtrOutput) Issuer() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidc) *string {
		if v == nil {
			return nil
		}
		return v.Issuer
	}).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcPtrOutput) LogoutUrl() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidc) *string {
		if v == nil {
			return nil
		}
		return v.LogoutUrl
	}).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcPtrOutput) RedirectUrl() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidc) *string {
		if v == nil {
			return nil
		}
		return v.RedirectUrl
	}).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcPtrOutput) Scopes() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidc) []string {
		if v == nil {
			return nil
		}
		return v.Scopes
	}).(pulumi.StringArrayOutput)
}

// SecretReference represents a Secret Reference. It has enough information to retrieve secret
// in any namespace
func (o AccessControlPolicySpecOidcPtrOutput) Secret() AccessControlPolicySpecOidcSecretPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidc) *AccessControlPolicySpecOidcSecret {
		if v == nil {
			return nil
		}
		return v.Secret
	}).(AccessControlPolicySpecOidcSecretPtrOutput)
}

// Session holds session configuration.
func (o AccessControlPolicySpecOidcPtrOutput) Session() AccessControlPolicySpecOidcSessionPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidc) *AccessControlPolicySpecOidcSession {
		if v == nil {
			return nil
		}
		return v.Session
	}).(AccessControlPolicySpecOidcSessionPtrOutput)
}

// StateCookie holds state cookie configuration.
func (o AccessControlPolicySpecOidcPtrOutput) StateCookie() AccessControlPolicySpecOidcStateCookiePtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidc) *AccessControlPolicySpecOidcStateCookie {
		if v == nil {
			return nil
		}
		return v.StateCookie
	}).(AccessControlPolicySpecOidcStateCookiePtrOutput)
}

type AccessControlPolicySpecOidcAuthParams struct {
}

type AccessControlPolicySpecOidcForwardHeaders struct {
}

// AccessControlPolicyOIDCGoogle holds the Google OIDC authentication configuration.
type AccessControlPolicySpecOidcGoogle struct {
	AuthParams map[string]string `pulumi:"authParams"`
	ClientId   *string           `pulumi:"clientId"`
	// Emails are the allowed emails to connect.
	Emails         []string          `pulumi:"emails"`
	ForwardHeaders map[string]string `pulumi:"forwardHeaders"`
	LogoutUrl      *string           `pulumi:"logoutUrl"`
	RedirectUrl    *string           `pulumi:"redirectUrl"`
	// SecretReference represents a Secret Reference. It has enough information to retrieve secret
	// in any namespace
	Secret *AccessControlPolicySpecOidcGoogleSecret `pulumi:"secret"`
	// Session holds session configuration.
	Session *AccessControlPolicySpecOidcGoogleSession `pulumi:"session"`
	// StateCookie holds state cookie configuration.
	StateCookie *AccessControlPolicySpecOidcGoogleStateCookie `pulumi:"stateCookie"`
}

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

	ToAccessControlPolicySpecOidcGoogleOutput() AccessControlPolicySpecOidcGoogleOutput
	ToAccessControlPolicySpecOidcGoogleOutputWithContext(context.Context) AccessControlPolicySpecOidcGoogleOutput
}

// AccessControlPolicyOIDCGoogle holds the Google OIDC authentication configuration.
type AccessControlPolicySpecOidcGoogleArgs struct {
	AuthParams pulumi.StringMapInput `pulumi:"authParams"`
	ClientId   pulumi.StringPtrInput `pulumi:"clientId"`
	// Emails are the allowed emails to connect.
	Emails         pulumi.StringArrayInput `pulumi:"emails"`
	ForwardHeaders pulumi.StringMapInput   `pulumi:"forwardHeaders"`
	LogoutUrl      pulumi.StringPtrInput   `pulumi:"logoutUrl"`
	RedirectUrl    pulumi.StringPtrInput   `pulumi:"redirectUrl"`
	// SecretReference represents a Secret Reference. It has enough information to retrieve secret
	// in any namespace
	Secret AccessControlPolicySpecOidcGoogleSecretPtrInput `pulumi:"secret"`
	// Session holds session configuration.
	Session AccessControlPolicySpecOidcGoogleSessionPtrInput `pulumi:"session"`
	// StateCookie holds state cookie configuration.
	StateCookie AccessControlPolicySpecOidcGoogleStateCookiePtrInput `pulumi:"stateCookie"`
}

func (AccessControlPolicySpecOidcGoogleArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecOidcGoogle)(nil)).Elem()
}

func (i AccessControlPolicySpecOidcGoogleArgs) ToAccessControlPolicySpecOidcGoogleOutput() AccessControlPolicySpecOidcGoogleOutput {
	return i.ToAccessControlPolicySpecOidcGoogleOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecOidcGoogleArgs) ToAccessControlPolicySpecOidcGoogleOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcGoogleOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOidcGoogleOutput)
}

func (i AccessControlPolicySpecOidcGoogleArgs) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecOidcGoogle] {
	return pulumix.Output[AccessControlPolicySpecOidcGoogle]{
		OutputState: i.ToAccessControlPolicySpecOidcGoogleOutputWithContext(ctx).OutputState,
	}
}

func (i AccessControlPolicySpecOidcGoogleArgs) ToAccessControlPolicySpecOidcGooglePtrOutput() AccessControlPolicySpecOidcGooglePtrOutput {
	return i.ToAccessControlPolicySpecOidcGooglePtrOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecOidcGoogleArgs) ToAccessControlPolicySpecOidcGooglePtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcGooglePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOidcGoogleOutput).ToAccessControlPolicySpecOidcGooglePtrOutputWithContext(ctx)
}

// AccessControlPolicySpecOidcGooglePtrInput is an input type that accepts AccessControlPolicySpecOidcGoogleArgs, AccessControlPolicySpecOidcGooglePtr and AccessControlPolicySpecOidcGooglePtrOutput values.
// You can construct a concrete instance of `AccessControlPolicySpecOidcGooglePtrInput` via:
//
//	        AccessControlPolicySpecOidcGoogleArgs{...}
//
//	or:
//
//	        nil
type AccessControlPolicySpecOidcGooglePtrInput interface {
	pulumi.Input

	ToAccessControlPolicySpecOidcGooglePtrOutput() AccessControlPolicySpecOidcGooglePtrOutput
	ToAccessControlPolicySpecOidcGooglePtrOutputWithContext(context.Context) AccessControlPolicySpecOidcGooglePtrOutput
}

type accessControlPolicySpecOidcGooglePtrType AccessControlPolicySpecOidcGoogleArgs

func AccessControlPolicySpecOidcGooglePtr(v *AccessControlPolicySpecOidcGoogleArgs) AccessControlPolicySpecOidcGooglePtrInput {
	return (*accessControlPolicySpecOidcGooglePtrType)(v)
}

func (*accessControlPolicySpecOidcGooglePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecOidcGoogle)(nil)).Elem()
}

func (i *accessControlPolicySpecOidcGooglePtrType) ToAccessControlPolicySpecOidcGooglePtrOutput() AccessControlPolicySpecOidcGooglePtrOutput {
	return i.ToAccessControlPolicySpecOidcGooglePtrOutputWithContext(context.Background())
}

func (i *accessControlPolicySpecOidcGooglePtrType) ToAccessControlPolicySpecOidcGooglePtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcGooglePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOidcGooglePtrOutput)
}

func (i *accessControlPolicySpecOidcGooglePtrType) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecOidcGoogle] {
	return pulumix.Output[*AccessControlPolicySpecOidcGoogle]{
		OutputState: i.ToAccessControlPolicySpecOidcGooglePtrOutputWithContext(ctx).OutputState,
	}
}

// AccessControlPolicyOIDCGoogle holds the Google OIDC authentication configuration.
type AccessControlPolicySpecOidcGoogleOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecOidcGoogleOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecOidcGoogle)(nil)).Elem()
}

func (o AccessControlPolicySpecOidcGoogleOutput) ToAccessControlPolicySpecOidcGoogleOutput() AccessControlPolicySpecOidcGoogleOutput {
	return o
}

func (o AccessControlPolicySpecOidcGoogleOutput) ToAccessControlPolicySpecOidcGoogleOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcGoogleOutput {
	return o
}

func (o AccessControlPolicySpecOidcGoogleOutput) ToAccessControlPolicySpecOidcGooglePtrOutput() AccessControlPolicySpecOidcGooglePtrOutput {
	return o.ToAccessControlPolicySpecOidcGooglePtrOutputWithContext(context.Background())
}

func (o AccessControlPolicySpecOidcGoogleOutput) ToAccessControlPolicySpecOidcGooglePtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcGooglePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v AccessControlPolicySpecOidcGoogle) *AccessControlPolicySpecOidcGoogle {
		return &v
	}).(AccessControlPolicySpecOidcGooglePtrOutput)
}

func (o AccessControlPolicySpecOidcGoogleOutput) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecOidcGoogle] {
	return pulumix.Output[AccessControlPolicySpecOidcGoogle]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicySpecOidcGoogleOutput) AuthParams() pulumi.StringMapOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcGoogle) map[string]string { return v.AuthParams }).(pulumi.StringMapOutput)
}

func (o AccessControlPolicySpecOidcGoogleOutput) ClientId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcGoogle) *string { return v.ClientId }).(pulumi.StringPtrOutput)
}

// Emails are the allowed emails to connect.
func (o AccessControlPolicySpecOidcGoogleOutput) Emails() pulumi.StringArrayOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcGoogle) []string { return v.Emails }).(pulumi.StringArrayOutput)
}

func (o AccessControlPolicySpecOidcGoogleOutput) ForwardHeaders() pulumi.StringMapOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcGoogle) map[string]string { return v.ForwardHeaders }).(pulumi.StringMapOutput)
}

func (o AccessControlPolicySpecOidcGoogleOutput) LogoutUrl() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcGoogle) *string { return v.LogoutUrl }).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcGoogleOutput) RedirectUrl() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcGoogle) *string { return v.RedirectUrl }).(pulumi.StringPtrOutput)
}

// SecretReference represents a Secret Reference. It has enough information to retrieve secret
// in any namespace
func (o AccessControlPolicySpecOidcGoogleOutput) Secret() AccessControlPolicySpecOidcGoogleSecretPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcGoogle) *AccessControlPolicySpecOidcGoogleSecret { return v.Secret }).(AccessControlPolicySpecOidcGoogleSecretPtrOutput)
}

// Session holds session configuration.
func (o AccessControlPolicySpecOidcGoogleOutput) Session() AccessControlPolicySpecOidcGoogleSessionPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcGoogle) *AccessControlPolicySpecOidcGoogleSession { return v.Session }).(AccessControlPolicySpecOidcGoogleSessionPtrOutput)
}

// StateCookie holds state cookie configuration.
func (o AccessControlPolicySpecOidcGoogleOutput) StateCookie() AccessControlPolicySpecOidcGoogleStateCookiePtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcGoogle) *AccessControlPolicySpecOidcGoogleStateCookie {
		return v.StateCookie
	}).(AccessControlPolicySpecOidcGoogleStateCookiePtrOutput)
}

type AccessControlPolicySpecOidcGooglePtrOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecOidcGooglePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecOidcGoogle)(nil)).Elem()
}

func (o AccessControlPolicySpecOidcGooglePtrOutput) ToAccessControlPolicySpecOidcGooglePtrOutput() AccessControlPolicySpecOidcGooglePtrOutput {
	return o
}

func (o AccessControlPolicySpecOidcGooglePtrOutput) ToAccessControlPolicySpecOidcGooglePtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcGooglePtrOutput {
	return o
}

func (o AccessControlPolicySpecOidcGooglePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecOidcGoogle] {
	return pulumix.Output[*AccessControlPolicySpecOidcGoogle]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicySpecOidcGooglePtrOutput) Elem() AccessControlPolicySpecOidcGoogleOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcGoogle) AccessControlPolicySpecOidcGoogle {
		if v != nil {
			return *v
		}
		var ret AccessControlPolicySpecOidcGoogle
		return ret
	}).(AccessControlPolicySpecOidcGoogleOutput)
}

func (o AccessControlPolicySpecOidcGooglePtrOutput) AuthParams() pulumi.StringMapOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcGoogle) map[string]string {
		if v == nil {
			return nil
		}
		return v.AuthParams
	}).(pulumi.StringMapOutput)
}

func (o AccessControlPolicySpecOidcGooglePtrOutput) ClientId() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcGoogle) *string {
		if v == nil {
			return nil
		}
		return v.ClientId
	}).(pulumi.StringPtrOutput)
}

// Emails are the allowed emails to connect.
func (o AccessControlPolicySpecOidcGooglePtrOutput) Emails() pulumi.StringArrayOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcGoogle) []string {
		if v == nil {
			return nil
		}
		return v.Emails
	}).(pulumi.StringArrayOutput)
}

func (o AccessControlPolicySpecOidcGooglePtrOutput) ForwardHeaders() pulumi.StringMapOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcGoogle) map[string]string {
		if v == nil {
			return nil
		}
		return v.ForwardHeaders
	}).(pulumi.StringMapOutput)
}

func (o AccessControlPolicySpecOidcGooglePtrOutput) LogoutUrl() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcGoogle) *string {
		if v == nil {
			return nil
		}
		return v.LogoutUrl
	}).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcGooglePtrOutput) RedirectUrl() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcGoogle) *string {
		if v == nil {
			return nil
		}
		return v.RedirectUrl
	}).(pulumi.StringPtrOutput)
}

// SecretReference represents a Secret Reference. It has enough information to retrieve secret
// in any namespace
func (o AccessControlPolicySpecOidcGooglePtrOutput) Secret() AccessControlPolicySpecOidcGoogleSecretPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcGoogle) *AccessControlPolicySpecOidcGoogleSecret {
		if v == nil {
			return nil
		}
		return v.Secret
	}).(AccessControlPolicySpecOidcGoogleSecretPtrOutput)
}

// Session holds session configuration.
func (o AccessControlPolicySpecOidcGooglePtrOutput) Session() AccessControlPolicySpecOidcGoogleSessionPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcGoogle) *AccessControlPolicySpecOidcGoogleSession {
		if v == nil {
			return nil
		}
		return v.Session
	}).(AccessControlPolicySpecOidcGoogleSessionPtrOutput)
}

// StateCookie holds state cookie configuration.
func (o AccessControlPolicySpecOidcGooglePtrOutput) StateCookie() AccessControlPolicySpecOidcGoogleStateCookiePtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcGoogle) *AccessControlPolicySpecOidcGoogleStateCookie {
		if v == nil {
			return nil
		}
		return v.StateCookie
	}).(AccessControlPolicySpecOidcGoogleStateCookiePtrOutput)
}

type AccessControlPolicySpecOidcGoogleAuthParams struct {
}

type AccessControlPolicySpecOidcGoogleForwardHeaders struct {
}

// SecretReference represents a Secret Reference. It has enough information to retrieve secret
// in any namespace
type AccessControlPolicySpecOidcGoogleSecret struct {
	// name is unique within a namespace to reference a secret resource.
	Name *string `pulumi:"name"`
	// namespace defines the space within which the secret name must be unique.
	Namespace *string `pulumi:"namespace"`
}

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

	ToAccessControlPolicySpecOidcGoogleSecretOutput() AccessControlPolicySpecOidcGoogleSecretOutput
	ToAccessControlPolicySpecOidcGoogleSecretOutputWithContext(context.Context) AccessControlPolicySpecOidcGoogleSecretOutput
}

// SecretReference represents a Secret Reference. It has enough information to retrieve secret
// in any namespace
type AccessControlPolicySpecOidcGoogleSecretArgs struct {
	// name is unique within a namespace to reference a secret resource.
	Name pulumi.StringPtrInput `pulumi:"name"`
	// namespace defines the space within which the secret name must be unique.
	Namespace pulumi.StringPtrInput `pulumi:"namespace"`
}

func (AccessControlPolicySpecOidcGoogleSecretArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecOidcGoogleSecret)(nil)).Elem()
}

func (i AccessControlPolicySpecOidcGoogleSecretArgs) ToAccessControlPolicySpecOidcGoogleSecretOutput() AccessControlPolicySpecOidcGoogleSecretOutput {
	return i.ToAccessControlPolicySpecOidcGoogleSecretOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecOidcGoogleSecretArgs) ToAccessControlPolicySpecOidcGoogleSecretOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcGoogleSecretOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOidcGoogleSecretOutput)
}

func (i AccessControlPolicySpecOidcGoogleSecretArgs) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecOidcGoogleSecret] {
	return pulumix.Output[AccessControlPolicySpecOidcGoogleSecret]{
		OutputState: i.ToAccessControlPolicySpecOidcGoogleSecretOutputWithContext(ctx).OutputState,
	}
}

func (i AccessControlPolicySpecOidcGoogleSecretArgs) ToAccessControlPolicySpecOidcGoogleSecretPtrOutput() AccessControlPolicySpecOidcGoogleSecretPtrOutput {
	return i.ToAccessControlPolicySpecOidcGoogleSecretPtrOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecOidcGoogleSecretArgs) ToAccessControlPolicySpecOidcGoogleSecretPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcGoogleSecretPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOidcGoogleSecretOutput).ToAccessControlPolicySpecOidcGoogleSecretPtrOutputWithContext(ctx)
}

// AccessControlPolicySpecOidcGoogleSecretPtrInput is an input type that accepts AccessControlPolicySpecOidcGoogleSecretArgs, AccessControlPolicySpecOidcGoogleSecretPtr and AccessControlPolicySpecOidcGoogleSecretPtrOutput values.
// You can construct a concrete instance of `AccessControlPolicySpecOidcGoogleSecretPtrInput` via:
//
//	        AccessControlPolicySpecOidcGoogleSecretArgs{...}
//
//	or:
//
//	        nil
type AccessControlPolicySpecOidcGoogleSecretPtrInput interface {
	pulumi.Input

	ToAccessControlPolicySpecOidcGoogleSecretPtrOutput() AccessControlPolicySpecOidcGoogleSecretPtrOutput
	ToAccessControlPolicySpecOidcGoogleSecretPtrOutputWithContext(context.Context) AccessControlPolicySpecOidcGoogleSecretPtrOutput
}

type accessControlPolicySpecOidcGoogleSecretPtrType AccessControlPolicySpecOidcGoogleSecretArgs

func AccessControlPolicySpecOidcGoogleSecretPtr(v *AccessControlPolicySpecOidcGoogleSecretArgs) AccessControlPolicySpecOidcGoogleSecretPtrInput {
	return (*accessControlPolicySpecOidcGoogleSecretPtrType)(v)
}

func (*accessControlPolicySpecOidcGoogleSecretPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecOidcGoogleSecret)(nil)).Elem()
}

func (i *accessControlPolicySpecOidcGoogleSecretPtrType) ToAccessControlPolicySpecOidcGoogleSecretPtrOutput() AccessControlPolicySpecOidcGoogleSecretPtrOutput {
	return i.ToAccessControlPolicySpecOidcGoogleSecretPtrOutputWithContext(context.Background())
}

func (i *accessControlPolicySpecOidcGoogleSecretPtrType) ToAccessControlPolicySpecOidcGoogleSecretPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcGoogleSecretPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOidcGoogleSecretPtrOutput)
}

func (i *accessControlPolicySpecOidcGoogleSecretPtrType) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecOidcGoogleSecret] {
	return pulumix.Output[*AccessControlPolicySpecOidcGoogleSecret]{
		OutputState: i.ToAccessControlPolicySpecOidcGoogleSecretPtrOutputWithContext(ctx).OutputState,
	}
}

// SecretReference represents a Secret Reference. It has enough information to retrieve secret
// in any namespace
type AccessControlPolicySpecOidcGoogleSecretOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecOidcGoogleSecretOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecOidcGoogleSecret)(nil)).Elem()
}

func (o AccessControlPolicySpecOidcGoogleSecretOutput) ToAccessControlPolicySpecOidcGoogleSecretOutput() AccessControlPolicySpecOidcGoogleSecretOutput {
	return o
}

func (o AccessControlPolicySpecOidcGoogleSecretOutput) ToAccessControlPolicySpecOidcGoogleSecretOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcGoogleSecretOutput {
	return o
}

func (o AccessControlPolicySpecOidcGoogleSecretOutput) ToAccessControlPolicySpecOidcGoogleSecretPtrOutput() AccessControlPolicySpecOidcGoogleSecretPtrOutput {
	return o.ToAccessControlPolicySpecOidcGoogleSecretPtrOutputWithContext(context.Background())
}

func (o AccessControlPolicySpecOidcGoogleSecretOutput) ToAccessControlPolicySpecOidcGoogleSecretPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcGoogleSecretPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v AccessControlPolicySpecOidcGoogleSecret) *AccessControlPolicySpecOidcGoogleSecret {
		return &v
	}).(AccessControlPolicySpecOidcGoogleSecretPtrOutput)
}

func (o AccessControlPolicySpecOidcGoogleSecretOutput) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecOidcGoogleSecret] {
	return pulumix.Output[AccessControlPolicySpecOidcGoogleSecret]{
		OutputState: o.OutputState,
	}
}

// name is unique within a namespace to reference a secret resource.
func (o AccessControlPolicySpecOidcGoogleSecretOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcGoogleSecret) *string { return v.Name }).(pulumi.StringPtrOutput)
}

// namespace defines the space within which the secret name must be unique.
func (o AccessControlPolicySpecOidcGoogleSecretOutput) Namespace() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcGoogleSecret) *string { return v.Namespace }).(pulumi.StringPtrOutput)
}

type AccessControlPolicySpecOidcGoogleSecretPtrOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecOidcGoogleSecretPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecOidcGoogleSecret)(nil)).Elem()
}

func (o AccessControlPolicySpecOidcGoogleSecretPtrOutput) ToAccessControlPolicySpecOidcGoogleSecretPtrOutput() AccessControlPolicySpecOidcGoogleSecretPtrOutput {
	return o
}

func (o AccessControlPolicySpecOidcGoogleSecretPtrOutput) ToAccessControlPolicySpecOidcGoogleSecretPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcGoogleSecretPtrOutput {
	return o
}

func (o AccessControlPolicySpecOidcGoogleSecretPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecOidcGoogleSecret] {
	return pulumix.Output[*AccessControlPolicySpecOidcGoogleSecret]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicySpecOidcGoogleSecretPtrOutput) Elem() AccessControlPolicySpecOidcGoogleSecretOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcGoogleSecret) AccessControlPolicySpecOidcGoogleSecret {
		if v != nil {
			return *v
		}
		var ret AccessControlPolicySpecOidcGoogleSecret
		return ret
	}).(AccessControlPolicySpecOidcGoogleSecretOutput)
}

// name is unique within a namespace to reference a secret resource.
func (o AccessControlPolicySpecOidcGoogleSecretPtrOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcGoogleSecret) *string {
		if v == nil {
			return nil
		}
		return v.Name
	}).(pulumi.StringPtrOutput)
}

// namespace defines the space within which the secret name must be unique.
func (o AccessControlPolicySpecOidcGoogleSecretPtrOutput) Namespace() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcGoogleSecret) *string {
		if v == nil {
			return nil
		}
		return v.Namespace
	}).(pulumi.StringPtrOutput)
}

// Session holds session configuration.
type AccessControlPolicySpecOidcGoogleSession struct {
	Domain   *string `pulumi:"domain"`
	Path     *string `pulumi:"path"`
	Refresh  *bool   `pulumi:"refresh"`
	SameSite *string `pulumi:"sameSite"`
	Secure   *bool   `pulumi:"secure"`
}

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

	ToAccessControlPolicySpecOidcGoogleSessionOutput() AccessControlPolicySpecOidcGoogleSessionOutput
	ToAccessControlPolicySpecOidcGoogleSessionOutputWithContext(context.Context) AccessControlPolicySpecOidcGoogleSessionOutput
}

// Session holds session configuration.
type AccessControlPolicySpecOidcGoogleSessionArgs struct {
	Domain   pulumi.StringPtrInput `pulumi:"domain"`
	Path     pulumi.StringPtrInput `pulumi:"path"`
	Refresh  pulumi.BoolPtrInput   `pulumi:"refresh"`
	SameSite pulumi.StringPtrInput `pulumi:"sameSite"`
	Secure   pulumi.BoolPtrInput   `pulumi:"secure"`
}

func (AccessControlPolicySpecOidcGoogleSessionArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecOidcGoogleSession)(nil)).Elem()
}

func (i AccessControlPolicySpecOidcGoogleSessionArgs) ToAccessControlPolicySpecOidcGoogleSessionOutput() AccessControlPolicySpecOidcGoogleSessionOutput {
	return i.ToAccessControlPolicySpecOidcGoogleSessionOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecOidcGoogleSessionArgs) ToAccessControlPolicySpecOidcGoogleSessionOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcGoogleSessionOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOidcGoogleSessionOutput)
}

func (i AccessControlPolicySpecOidcGoogleSessionArgs) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecOidcGoogleSession] {
	return pulumix.Output[AccessControlPolicySpecOidcGoogleSession]{
		OutputState: i.ToAccessControlPolicySpecOidcGoogleSessionOutputWithContext(ctx).OutputState,
	}
}

func (i AccessControlPolicySpecOidcGoogleSessionArgs) ToAccessControlPolicySpecOidcGoogleSessionPtrOutput() AccessControlPolicySpecOidcGoogleSessionPtrOutput {
	return i.ToAccessControlPolicySpecOidcGoogleSessionPtrOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecOidcGoogleSessionArgs) ToAccessControlPolicySpecOidcGoogleSessionPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcGoogleSessionPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOidcGoogleSessionOutput).ToAccessControlPolicySpecOidcGoogleSessionPtrOutputWithContext(ctx)
}

// AccessControlPolicySpecOidcGoogleSessionPtrInput is an input type that accepts AccessControlPolicySpecOidcGoogleSessionArgs, AccessControlPolicySpecOidcGoogleSessionPtr and AccessControlPolicySpecOidcGoogleSessionPtrOutput values.
// You can construct a concrete instance of `AccessControlPolicySpecOidcGoogleSessionPtrInput` via:
//
//	        AccessControlPolicySpecOidcGoogleSessionArgs{...}
//
//	or:
//
//	        nil
type AccessControlPolicySpecOidcGoogleSessionPtrInput interface {
	pulumi.Input

	ToAccessControlPolicySpecOidcGoogleSessionPtrOutput() AccessControlPolicySpecOidcGoogleSessionPtrOutput
	ToAccessControlPolicySpecOidcGoogleSessionPtrOutputWithContext(context.Context) AccessControlPolicySpecOidcGoogleSessionPtrOutput
}

type accessControlPolicySpecOidcGoogleSessionPtrType AccessControlPolicySpecOidcGoogleSessionArgs

func AccessControlPolicySpecOidcGoogleSessionPtr(v *AccessControlPolicySpecOidcGoogleSessionArgs) AccessControlPolicySpecOidcGoogleSessionPtrInput {
	return (*accessControlPolicySpecOidcGoogleSessionPtrType)(v)
}

func (*accessControlPolicySpecOidcGoogleSessionPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecOidcGoogleSession)(nil)).Elem()
}

func (i *accessControlPolicySpecOidcGoogleSessionPtrType) ToAccessControlPolicySpecOidcGoogleSessionPtrOutput() AccessControlPolicySpecOidcGoogleSessionPtrOutput {
	return i.ToAccessControlPolicySpecOidcGoogleSessionPtrOutputWithContext(context.Background())
}

func (i *accessControlPolicySpecOidcGoogleSessionPtrType) ToAccessControlPolicySpecOidcGoogleSessionPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcGoogleSessionPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOidcGoogleSessionPtrOutput)
}

func (i *accessControlPolicySpecOidcGoogleSessionPtrType) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecOidcGoogleSession] {
	return pulumix.Output[*AccessControlPolicySpecOidcGoogleSession]{
		OutputState: i.ToAccessControlPolicySpecOidcGoogleSessionPtrOutputWithContext(ctx).OutputState,
	}
}

// Session holds session configuration.
type AccessControlPolicySpecOidcGoogleSessionOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecOidcGoogleSessionOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecOidcGoogleSession)(nil)).Elem()
}

func (o AccessControlPolicySpecOidcGoogleSessionOutput) ToAccessControlPolicySpecOidcGoogleSessionOutput() AccessControlPolicySpecOidcGoogleSessionOutput {
	return o
}

func (o AccessControlPolicySpecOidcGoogleSessionOutput) ToAccessControlPolicySpecOidcGoogleSessionOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcGoogleSessionOutput {
	return o
}

func (o AccessControlPolicySpecOidcGoogleSessionOutput) ToAccessControlPolicySpecOidcGoogleSessionPtrOutput() AccessControlPolicySpecOidcGoogleSessionPtrOutput {
	return o.ToAccessControlPolicySpecOidcGoogleSessionPtrOutputWithContext(context.Background())
}

func (o AccessControlPolicySpecOidcGoogleSessionOutput) ToAccessControlPolicySpecOidcGoogleSessionPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcGoogleSessionPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v AccessControlPolicySpecOidcGoogleSession) *AccessControlPolicySpecOidcGoogleSession {
		return &v
	}).(AccessControlPolicySpecOidcGoogleSessionPtrOutput)
}

func (o AccessControlPolicySpecOidcGoogleSessionOutput) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecOidcGoogleSession] {
	return pulumix.Output[AccessControlPolicySpecOidcGoogleSession]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicySpecOidcGoogleSessionOutput) Domain() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcGoogleSession) *string { return v.Domain }).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcGoogleSessionOutput) Path() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcGoogleSession) *string { return v.Path }).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcGoogleSessionOutput) Refresh() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcGoogleSession) *bool { return v.Refresh }).(pulumi.BoolPtrOutput)
}

func (o AccessControlPolicySpecOidcGoogleSessionOutput) SameSite() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcGoogleSession) *string { return v.SameSite }).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcGoogleSessionOutput) Secure() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcGoogleSession) *bool { return v.Secure }).(pulumi.BoolPtrOutput)
}

type AccessControlPolicySpecOidcGoogleSessionPtrOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecOidcGoogleSessionPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecOidcGoogleSession)(nil)).Elem()
}

func (o AccessControlPolicySpecOidcGoogleSessionPtrOutput) ToAccessControlPolicySpecOidcGoogleSessionPtrOutput() AccessControlPolicySpecOidcGoogleSessionPtrOutput {
	return o
}

func (o AccessControlPolicySpecOidcGoogleSessionPtrOutput) ToAccessControlPolicySpecOidcGoogleSessionPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcGoogleSessionPtrOutput {
	return o
}

func (o AccessControlPolicySpecOidcGoogleSessionPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecOidcGoogleSession] {
	return pulumix.Output[*AccessControlPolicySpecOidcGoogleSession]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicySpecOidcGoogleSessionPtrOutput) Elem() AccessControlPolicySpecOidcGoogleSessionOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcGoogleSession) AccessControlPolicySpecOidcGoogleSession {
		if v != nil {
			return *v
		}
		var ret AccessControlPolicySpecOidcGoogleSession
		return ret
	}).(AccessControlPolicySpecOidcGoogleSessionOutput)
}

func (o AccessControlPolicySpecOidcGoogleSessionPtrOutput) Domain() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcGoogleSession) *string {
		if v == nil {
			return nil
		}
		return v.Domain
	}).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcGoogleSessionPtrOutput) Path() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcGoogleSession) *string {
		if v == nil {
			return nil
		}
		return v.Path
	}).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcGoogleSessionPtrOutput) Refresh() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcGoogleSession) *bool {
		if v == nil {
			return nil
		}
		return v.Refresh
	}).(pulumi.BoolPtrOutput)
}

func (o AccessControlPolicySpecOidcGoogleSessionPtrOutput) SameSite() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcGoogleSession) *string {
		if v == nil {
			return nil
		}
		return v.SameSite
	}).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcGoogleSessionPtrOutput) Secure() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcGoogleSession) *bool {
		if v == nil {
			return nil
		}
		return v.Secure
	}).(pulumi.BoolPtrOutput)
}

// StateCookie holds state cookie configuration.
type AccessControlPolicySpecOidcGoogleStateCookie struct {
	Domain   *string `pulumi:"domain"`
	Path     *string `pulumi:"path"`
	SameSite *string `pulumi:"sameSite"`
	Secure   *bool   `pulumi:"secure"`
}

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

	ToAccessControlPolicySpecOidcGoogleStateCookieOutput() AccessControlPolicySpecOidcGoogleStateCookieOutput
	ToAccessControlPolicySpecOidcGoogleStateCookieOutputWithContext(context.Context) AccessControlPolicySpecOidcGoogleStateCookieOutput
}

// StateCookie holds state cookie configuration.
type AccessControlPolicySpecOidcGoogleStateCookieArgs struct {
	Domain   pulumi.StringPtrInput `pulumi:"domain"`
	Path     pulumi.StringPtrInput `pulumi:"path"`
	SameSite pulumi.StringPtrInput `pulumi:"sameSite"`
	Secure   pulumi.BoolPtrInput   `pulumi:"secure"`
}

func (AccessControlPolicySpecOidcGoogleStateCookieArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecOidcGoogleStateCookie)(nil)).Elem()
}

func (i AccessControlPolicySpecOidcGoogleStateCookieArgs) ToAccessControlPolicySpecOidcGoogleStateCookieOutput() AccessControlPolicySpecOidcGoogleStateCookieOutput {
	return i.ToAccessControlPolicySpecOidcGoogleStateCookieOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecOidcGoogleStateCookieArgs) ToAccessControlPolicySpecOidcGoogleStateCookieOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcGoogleStateCookieOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOidcGoogleStateCookieOutput)
}

func (i AccessControlPolicySpecOidcGoogleStateCookieArgs) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecOidcGoogleStateCookie] {
	return pulumix.Output[AccessControlPolicySpecOidcGoogleStateCookie]{
		OutputState: i.ToAccessControlPolicySpecOidcGoogleStateCookieOutputWithContext(ctx).OutputState,
	}
}

func (i AccessControlPolicySpecOidcGoogleStateCookieArgs) ToAccessControlPolicySpecOidcGoogleStateCookiePtrOutput() AccessControlPolicySpecOidcGoogleStateCookiePtrOutput {
	return i.ToAccessControlPolicySpecOidcGoogleStateCookiePtrOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecOidcGoogleStateCookieArgs) ToAccessControlPolicySpecOidcGoogleStateCookiePtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcGoogleStateCookiePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOidcGoogleStateCookieOutput).ToAccessControlPolicySpecOidcGoogleStateCookiePtrOutputWithContext(ctx)
}

// AccessControlPolicySpecOidcGoogleStateCookiePtrInput is an input type that accepts AccessControlPolicySpecOidcGoogleStateCookieArgs, AccessControlPolicySpecOidcGoogleStateCookiePtr and AccessControlPolicySpecOidcGoogleStateCookiePtrOutput values.
// You can construct a concrete instance of `AccessControlPolicySpecOidcGoogleStateCookiePtrInput` via:
//
//	        AccessControlPolicySpecOidcGoogleStateCookieArgs{...}
//
//	or:
//
//	        nil
type AccessControlPolicySpecOidcGoogleStateCookiePtrInput interface {
	pulumi.Input

	ToAccessControlPolicySpecOidcGoogleStateCookiePtrOutput() AccessControlPolicySpecOidcGoogleStateCookiePtrOutput
	ToAccessControlPolicySpecOidcGoogleStateCookiePtrOutputWithContext(context.Context) AccessControlPolicySpecOidcGoogleStateCookiePtrOutput
}

type accessControlPolicySpecOidcGoogleStateCookiePtrType AccessControlPolicySpecOidcGoogleStateCookieArgs

func AccessControlPolicySpecOidcGoogleStateCookiePtr(v *AccessControlPolicySpecOidcGoogleStateCookieArgs) AccessControlPolicySpecOidcGoogleStateCookiePtrInput {
	return (*accessControlPolicySpecOidcGoogleStateCookiePtrType)(v)
}

func (*accessControlPolicySpecOidcGoogleStateCookiePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecOidcGoogleStateCookie)(nil)).Elem()
}

func (i *accessControlPolicySpecOidcGoogleStateCookiePtrType) ToAccessControlPolicySpecOidcGoogleStateCookiePtrOutput() AccessControlPolicySpecOidcGoogleStateCookiePtrOutput {
	return i.ToAccessControlPolicySpecOidcGoogleStateCookiePtrOutputWithContext(context.Background())
}

func (i *accessControlPolicySpecOidcGoogleStateCookiePtrType) ToAccessControlPolicySpecOidcGoogleStateCookiePtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcGoogleStateCookiePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOidcGoogleStateCookiePtrOutput)
}

func (i *accessControlPolicySpecOidcGoogleStateCookiePtrType) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecOidcGoogleStateCookie] {
	return pulumix.Output[*AccessControlPolicySpecOidcGoogleStateCookie]{
		OutputState: i.ToAccessControlPolicySpecOidcGoogleStateCookiePtrOutputWithContext(ctx).OutputState,
	}
}

// StateCookie holds state cookie configuration.
type AccessControlPolicySpecOidcGoogleStateCookieOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecOidcGoogleStateCookieOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecOidcGoogleStateCookie)(nil)).Elem()
}

func (o AccessControlPolicySpecOidcGoogleStateCookieOutput) ToAccessControlPolicySpecOidcGoogleStateCookieOutput() AccessControlPolicySpecOidcGoogleStateCookieOutput {
	return o
}

func (o AccessControlPolicySpecOidcGoogleStateCookieOutput) ToAccessControlPolicySpecOidcGoogleStateCookieOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcGoogleStateCookieOutput {
	return o
}

func (o AccessControlPolicySpecOidcGoogleStateCookieOutput) ToAccessControlPolicySpecOidcGoogleStateCookiePtrOutput() AccessControlPolicySpecOidcGoogleStateCookiePtrOutput {
	return o.ToAccessControlPolicySpecOidcGoogleStateCookiePtrOutputWithContext(context.Background())
}

func (o AccessControlPolicySpecOidcGoogleStateCookieOutput) ToAccessControlPolicySpecOidcGoogleStateCookiePtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcGoogleStateCookiePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v AccessControlPolicySpecOidcGoogleStateCookie) *AccessControlPolicySpecOidcGoogleStateCookie {
		return &v
	}).(AccessControlPolicySpecOidcGoogleStateCookiePtrOutput)
}

func (o AccessControlPolicySpecOidcGoogleStateCookieOutput) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecOidcGoogleStateCookie] {
	return pulumix.Output[AccessControlPolicySpecOidcGoogleStateCookie]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicySpecOidcGoogleStateCookieOutput) Domain() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcGoogleStateCookie) *string { return v.Domain }).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcGoogleStateCookieOutput) Path() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcGoogleStateCookie) *string { return v.Path }).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcGoogleStateCookieOutput) SameSite() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcGoogleStateCookie) *string { return v.SameSite }).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcGoogleStateCookieOutput) Secure() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcGoogleStateCookie) *bool { return v.Secure }).(pulumi.BoolPtrOutput)
}

type AccessControlPolicySpecOidcGoogleStateCookiePtrOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecOidcGoogleStateCookiePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecOidcGoogleStateCookie)(nil)).Elem()
}

func (o AccessControlPolicySpecOidcGoogleStateCookiePtrOutput) ToAccessControlPolicySpecOidcGoogleStateCookiePtrOutput() AccessControlPolicySpecOidcGoogleStateCookiePtrOutput {
	return o
}

func (o AccessControlPolicySpecOidcGoogleStateCookiePtrOutput) ToAccessControlPolicySpecOidcGoogleStateCookiePtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcGoogleStateCookiePtrOutput {
	return o
}

func (o AccessControlPolicySpecOidcGoogleStateCookiePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecOidcGoogleStateCookie] {
	return pulumix.Output[*AccessControlPolicySpecOidcGoogleStateCookie]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicySpecOidcGoogleStateCookiePtrOutput) Elem() AccessControlPolicySpecOidcGoogleStateCookieOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcGoogleStateCookie) AccessControlPolicySpecOidcGoogleStateCookie {
		if v != nil {
			return *v
		}
		var ret AccessControlPolicySpecOidcGoogleStateCookie
		return ret
	}).(AccessControlPolicySpecOidcGoogleStateCookieOutput)
}

func (o AccessControlPolicySpecOidcGoogleStateCookiePtrOutput) Domain() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcGoogleStateCookie) *string {
		if v == nil {
			return nil
		}
		return v.Domain
	}).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcGoogleStateCookiePtrOutput) Path() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcGoogleStateCookie) *string {
		if v == nil {
			return nil
		}
		return v.Path
	}).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcGoogleStateCookiePtrOutput) SameSite() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcGoogleStateCookie) *string {
		if v == nil {
			return nil
		}
		return v.SameSite
	}).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcGoogleStateCookiePtrOutput) Secure() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcGoogleStateCookie) *bool {
		if v == nil {
			return nil
		}
		return v.Secure
	}).(pulumi.BoolPtrOutput)
}

// SecretReference represents a Secret Reference. It has enough information to retrieve secret
// in any namespace
type AccessControlPolicySpecOidcSecret struct {
	// name is unique within a namespace to reference a secret resource.
	Name *string `pulumi:"name"`
	// namespace defines the space within which the secret name must be unique.
	Namespace *string `pulumi:"namespace"`
}

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

	ToAccessControlPolicySpecOidcSecretOutput() AccessControlPolicySpecOidcSecretOutput
	ToAccessControlPolicySpecOidcSecretOutputWithContext(context.Context) AccessControlPolicySpecOidcSecretOutput
}

// SecretReference represents a Secret Reference. It has enough information to retrieve secret
// in any namespace
type AccessControlPolicySpecOidcSecretArgs struct {
	// name is unique within a namespace to reference a secret resource.
	Name pulumi.StringPtrInput `pulumi:"name"`
	// namespace defines the space within which the secret name must be unique.
	Namespace pulumi.StringPtrInput `pulumi:"namespace"`
}

func (AccessControlPolicySpecOidcSecretArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecOidcSecret)(nil)).Elem()
}

func (i AccessControlPolicySpecOidcSecretArgs) ToAccessControlPolicySpecOidcSecretOutput() AccessControlPolicySpecOidcSecretOutput {
	return i.ToAccessControlPolicySpecOidcSecretOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecOidcSecretArgs) ToAccessControlPolicySpecOidcSecretOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcSecretOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOidcSecretOutput)
}

func (i AccessControlPolicySpecOidcSecretArgs) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecOidcSecret] {
	return pulumix.Output[AccessControlPolicySpecOidcSecret]{
		OutputState: i.ToAccessControlPolicySpecOidcSecretOutputWithContext(ctx).OutputState,
	}
}

func (i AccessControlPolicySpecOidcSecretArgs) ToAccessControlPolicySpecOidcSecretPtrOutput() AccessControlPolicySpecOidcSecretPtrOutput {
	return i.ToAccessControlPolicySpecOidcSecretPtrOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecOidcSecretArgs) ToAccessControlPolicySpecOidcSecretPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcSecretPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOidcSecretOutput).ToAccessControlPolicySpecOidcSecretPtrOutputWithContext(ctx)
}

// AccessControlPolicySpecOidcSecretPtrInput is an input type that accepts AccessControlPolicySpecOidcSecretArgs, AccessControlPolicySpecOidcSecretPtr and AccessControlPolicySpecOidcSecretPtrOutput values.
// You can construct a concrete instance of `AccessControlPolicySpecOidcSecretPtrInput` via:
//
//	        AccessControlPolicySpecOidcSecretArgs{...}
//
//	or:
//
//	        nil
type AccessControlPolicySpecOidcSecretPtrInput interface {
	pulumi.Input

	ToAccessControlPolicySpecOidcSecretPtrOutput() AccessControlPolicySpecOidcSecretPtrOutput
	ToAccessControlPolicySpecOidcSecretPtrOutputWithContext(context.Context) AccessControlPolicySpecOidcSecretPtrOutput
}

type accessControlPolicySpecOidcSecretPtrType AccessControlPolicySpecOidcSecretArgs

func AccessControlPolicySpecOidcSecretPtr(v *AccessControlPolicySpecOidcSecretArgs) AccessControlPolicySpecOidcSecretPtrInput {
	return (*accessControlPolicySpecOidcSecretPtrType)(v)
}

func (*accessControlPolicySpecOidcSecretPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecOidcSecret)(nil)).Elem()
}

func (i *accessControlPolicySpecOidcSecretPtrType) ToAccessControlPolicySpecOidcSecretPtrOutput() AccessControlPolicySpecOidcSecretPtrOutput {
	return i.ToAccessControlPolicySpecOidcSecretPtrOutputWithContext(context.Background())
}

func (i *accessControlPolicySpecOidcSecretPtrType) ToAccessControlPolicySpecOidcSecretPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcSecretPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOidcSecretPtrOutput)
}

func (i *accessControlPolicySpecOidcSecretPtrType) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecOidcSecret] {
	return pulumix.Output[*AccessControlPolicySpecOidcSecret]{
		OutputState: i.ToAccessControlPolicySpecOidcSecretPtrOutputWithContext(ctx).OutputState,
	}
}

// SecretReference represents a Secret Reference. It has enough information to retrieve secret
// in any namespace
type AccessControlPolicySpecOidcSecretOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecOidcSecretOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecOidcSecret)(nil)).Elem()
}

func (o AccessControlPolicySpecOidcSecretOutput) ToAccessControlPolicySpecOidcSecretOutput() AccessControlPolicySpecOidcSecretOutput {
	return o
}

func (o AccessControlPolicySpecOidcSecretOutput) ToAccessControlPolicySpecOidcSecretOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcSecretOutput {
	return o
}

func (o AccessControlPolicySpecOidcSecretOutput) ToAccessControlPolicySpecOidcSecretPtrOutput() AccessControlPolicySpecOidcSecretPtrOutput {
	return o.ToAccessControlPolicySpecOidcSecretPtrOutputWithContext(context.Background())
}

func (o AccessControlPolicySpecOidcSecretOutput) ToAccessControlPolicySpecOidcSecretPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcSecretPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v AccessControlPolicySpecOidcSecret) *AccessControlPolicySpecOidcSecret {
		return &v
	}).(AccessControlPolicySpecOidcSecretPtrOutput)
}

func (o AccessControlPolicySpecOidcSecretOutput) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecOidcSecret] {
	return pulumix.Output[AccessControlPolicySpecOidcSecret]{
		OutputState: o.OutputState,
	}
}

// name is unique within a namespace to reference a secret resource.
func (o AccessControlPolicySpecOidcSecretOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcSecret) *string { return v.Name }).(pulumi.StringPtrOutput)
}

// namespace defines the space within which the secret name must be unique.
func (o AccessControlPolicySpecOidcSecretOutput) Namespace() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcSecret) *string { return v.Namespace }).(pulumi.StringPtrOutput)
}

type AccessControlPolicySpecOidcSecretPtrOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecOidcSecretPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecOidcSecret)(nil)).Elem()
}

func (o AccessControlPolicySpecOidcSecretPtrOutput) ToAccessControlPolicySpecOidcSecretPtrOutput() AccessControlPolicySpecOidcSecretPtrOutput {
	return o
}

func (o AccessControlPolicySpecOidcSecretPtrOutput) ToAccessControlPolicySpecOidcSecretPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcSecretPtrOutput {
	return o
}

func (o AccessControlPolicySpecOidcSecretPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecOidcSecret] {
	return pulumix.Output[*AccessControlPolicySpecOidcSecret]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicySpecOidcSecretPtrOutput) Elem() AccessControlPolicySpecOidcSecretOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcSecret) AccessControlPolicySpecOidcSecret {
		if v != nil {
			return *v
		}
		var ret AccessControlPolicySpecOidcSecret
		return ret
	}).(AccessControlPolicySpecOidcSecretOutput)
}

// name is unique within a namespace to reference a secret resource.
func (o AccessControlPolicySpecOidcSecretPtrOutput) Name() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcSecret) *string {
		if v == nil {
			return nil
		}
		return v.Name
	}).(pulumi.StringPtrOutput)
}

// namespace defines the space within which the secret name must be unique.
func (o AccessControlPolicySpecOidcSecretPtrOutput) Namespace() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcSecret) *string {
		if v == nil {
			return nil
		}
		return v.Namespace
	}).(pulumi.StringPtrOutput)
}

// Session holds session configuration.
type AccessControlPolicySpecOidcSession struct {
	Domain   *string `pulumi:"domain"`
	Path     *string `pulumi:"path"`
	Refresh  *bool   `pulumi:"refresh"`
	SameSite *string `pulumi:"sameSite"`
	Secure   *bool   `pulumi:"secure"`
}

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

	ToAccessControlPolicySpecOidcSessionOutput() AccessControlPolicySpecOidcSessionOutput
	ToAccessControlPolicySpecOidcSessionOutputWithContext(context.Context) AccessControlPolicySpecOidcSessionOutput
}

// Session holds session configuration.
type AccessControlPolicySpecOidcSessionArgs struct {
	Domain   pulumi.StringPtrInput `pulumi:"domain"`
	Path     pulumi.StringPtrInput `pulumi:"path"`
	Refresh  pulumi.BoolPtrInput   `pulumi:"refresh"`
	SameSite pulumi.StringPtrInput `pulumi:"sameSite"`
	Secure   pulumi.BoolPtrInput   `pulumi:"secure"`
}

func (AccessControlPolicySpecOidcSessionArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecOidcSession)(nil)).Elem()
}

func (i AccessControlPolicySpecOidcSessionArgs) ToAccessControlPolicySpecOidcSessionOutput() AccessControlPolicySpecOidcSessionOutput {
	return i.ToAccessControlPolicySpecOidcSessionOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecOidcSessionArgs) ToAccessControlPolicySpecOidcSessionOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcSessionOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOidcSessionOutput)
}

func (i AccessControlPolicySpecOidcSessionArgs) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecOidcSession] {
	return pulumix.Output[AccessControlPolicySpecOidcSession]{
		OutputState: i.ToAccessControlPolicySpecOidcSessionOutputWithContext(ctx).OutputState,
	}
}

func (i AccessControlPolicySpecOidcSessionArgs) ToAccessControlPolicySpecOidcSessionPtrOutput() AccessControlPolicySpecOidcSessionPtrOutput {
	return i.ToAccessControlPolicySpecOidcSessionPtrOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecOidcSessionArgs) ToAccessControlPolicySpecOidcSessionPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcSessionPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOidcSessionOutput).ToAccessControlPolicySpecOidcSessionPtrOutputWithContext(ctx)
}

// AccessControlPolicySpecOidcSessionPtrInput is an input type that accepts AccessControlPolicySpecOidcSessionArgs, AccessControlPolicySpecOidcSessionPtr and AccessControlPolicySpecOidcSessionPtrOutput values.
// You can construct a concrete instance of `AccessControlPolicySpecOidcSessionPtrInput` via:
//
//	        AccessControlPolicySpecOidcSessionArgs{...}
//
//	or:
//
//	        nil
type AccessControlPolicySpecOidcSessionPtrInput interface {
	pulumi.Input

	ToAccessControlPolicySpecOidcSessionPtrOutput() AccessControlPolicySpecOidcSessionPtrOutput
	ToAccessControlPolicySpecOidcSessionPtrOutputWithContext(context.Context) AccessControlPolicySpecOidcSessionPtrOutput
}

type accessControlPolicySpecOidcSessionPtrType AccessControlPolicySpecOidcSessionArgs

func AccessControlPolicySpecOidcSessionPtr(v *AccessControlPolicySpecOidcSessionArgs) AccessControlPolicySpecOidcSessionPtrInput {
	return (*accessControlPolicySpecOidcSessionPtrType)(v)
}

func (*accessControlPolicySpecOidcSessionPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecOidcSession)(nil)).Elem()
}

func (i *accessControlPolicySpecOidcSessionPtrType) ToAccessControlPolicySpecOidcSessionPtrOutput() AccessControlPolicySpecOidcSessionPtrOutput {
	return i.ToAccessControlPolicySpecOidcSessionPtrOutputWithContext(context.Background())
}

func (i *accessControlPolicySpecOidcSessionPtrType) ToAccessControlPolicySpecOidcSessionPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcSessionPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOidcSessionPtrOutput)
}

func (i *accessControlPolicySpecOidcSessionPtrType) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecOidcSession] {
	return pulumix.Output[*AccessControlPolicySpecOidcSession]{
		OutputState: i.ToAccessControlPolicySpecOidcSessionPtrOutputWithContext(ctx).OutputState,
	}
}

// Session holds session configuration.
type AccessControlPolicySpecOidcSessionOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecOidcSessionOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecOidcSession)(nil)).Elem()
}

func (o AccessControlPolicySpecOidcSessionOutput) ToAccessControlPolicySpecOidcSessionOutput() AccessControlPolicySpecOidcSessionOutput {
	return o
}

func (o AccessControlPolicySpecOidcSessionOutput) ToAccessControlPolicySpecOidcSessionOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcSessionOutput {
	return o
}

func (o AccessControlPolicySpecOidcSessionOutput) ToAccessControlPolicySpecOidcSessionPtrOutput() AccessControlPolicySpecOidcSessionPtrOutput {
	return o.ToAccessControlPolicySpecOidcSessionPtrOutputWithContext(context.Background())
}

func (o AccessControlPolicySpecOidcSessionOutput) ToAccessControlPolicySpecOidcSessionPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcSessionPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v AccessControlPolicySpecOidcSession) *AccessControlPolicySpecOidcSession {
		return &v
	}).(AccessControlPolicySpecOidcSessionPtrOutput)
}

func (o AccessControlPolicySpecOidcSessionOutput) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecOidcSession] {
	return pulumix.Output[AccessControlPolicySpecOidcSession]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicySpecOidcSessionOutput) Domain() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcSession) *string { return v.Domain }).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcSessionOutput) Path() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcSession) *string { return v.Path }).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcSessionOutput) Refresh() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcSession) *bool { return v.Refresh }).(pulumi.BoolPtrOutput)
}

func (o AccessControlPolicySpecOidcSessionOutput) SameSite() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcSession) *string { return v.SameSite }).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcSessionOutput) Secure() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcSession) *bool { return v.Secure }).(pulumi.BoolPtrOutput)
}

type AccessControlPolicySpecOidcSessionPtrOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecOidcSessionPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecOidcSession)(nil)).Elem()
}

func (o AccessControlPolicySpecOidcSessionPtrOutput) ToAccessControlPolicySpecOidcSessionPtrOutput() AccessControlPolicySpecOidcSessionPtrOutput {
	return o
}

func (o AccessControlPolicySpecOidcSessionPtrOutput) ToAccessControlPolicySpecOidcSessionPtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcSessionPtrOutput {
	return o
}

func (o AccessControlPolicySpecOidcSessionPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecOidcSession] {
	return pulumix.Output[*AccessControlPolicySpecOidcSession]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicySpecOidcSessionPtrOutput) Elem() AccessControlPolicySpecOidcSessionOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcSession) AccessControlPolicySpecOidcSession {
		if v != nil {
			return *v
		}
		var ret AccessControlPolicySpecOidcSession
		return ret
	}).(AccessControlPolicySpecOidcSessionOutput)
}

func (o AccessControlPolicySpecOidcSessionPtrOutput) Domain() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcSession) *string {
		if v == nil {
			return nil
		}
		return v.Domain
	}).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcSessionPtrOutput) Path() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcSession) *string {
		if v == nil {
			return nil
		}
		return v.Path
	}).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcSessionPtrOutput) Refresh() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcSession) *bool {
		if v == nil {
			return nil
		}
		return v.Refresh
	}).(pulumi.BoolPtrOutput)
}

func (o AccessControlPolicySpecOidcSessionPtrOutput) SameSite() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcSession) *string {
		if v == nil {
			return nil
		}
		return v.SameSite
	}).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcSessionPtrOutput) Secure() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcSession) *bool {
		if v == nil {
			return nil
		}
		return v.Secure
	}).(pulumi.BoolPtrOutput)
}

// StateCookie holds state cookie configuration.
type AccessControlPolicySpecOidcStateCookie struct {
	Domain   *string `pulumi:"domain"`
	Path     *string `pulumi:"path"`
	SameSite *string `pulumi:"sameSite"`
	Secure   *bool   `pulumi:"secure"`
}

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

	ToAccessControlPolicySpecOidcStateCookieOutput() AccessControlPolicySpecOidcStateCookieOutput
	ToAccessControlPolicySpecOidcStateCookieOutputWithContext(context.Context) AccessControlPolicySpecOidcStateCookieOutput
}

// StateCookie holds state cookie configuration.
type AccessControlPolicySpecOidcStateCookieArgs struct {
	Domain   pulumi.StringPtrInput `pulumi:"domain"`
	Path     pulumi.StringPtrInput `pulumi:"path"`
	SameSite pulumi.StringPtrInput `pulumi:"sameSite"`
	Secure   pulumi.BoolPtrInput   `pulumi:"secure"`
}

func (AccessControlPolicySpecOidcStateCookieArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecOidcStateCookie)(nil)).Elem()
}

func (i AccessControlPolicySpecOidcStateCookieArgs) ToAccessControlPolicySpecOidcStateCookieOutput() AccessControlPolicySpecOidcStateCookieOutput {
	return i.ToAccessControlPolicySpecOidcStateCookieOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecOidcStateCookieArgs) ToAccessControlPolicySpecOidcStateCookieOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcStateCookieOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOidcStateCookieOutput)
}

func (i AccessControlPolicySpecOidcStateCookieArgs) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecOidcStateCookie] {
	return pulumix.Output[AccessControlPolicySpecOidcStateCookie]{
		OutputState: i.ToAccessControlPolicySpecOidcStateCookieOutputWithContext(ctx).OutputState,
	}
}

func (i AccessControlPolicySpecOidcStateCookieArgs) ToAccessControlPolicySpecOidcStateCookiePtrOutput() AccessControlPolicySpecOidcStateCookiePtrOutput {
	return i.ToAccessControlPolicySpecOidcStateCookiePtrOutputWithContext(context.Background())
}

func (i AccessControlPolicySpecOidcStateCookieArgs) ToAccessControlPolicySpecOidcStateCookiePtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcStateCookiePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOidcStateCookieOutput).ToAccessControlPolicySpecOidcStateCookiePtrOutputWithContext(ctx)
}

// AccessControlPolicySpecOidcStateCookiePtrInput is an input type that accepts AccessControlPolicySpecOidcStateCookieArgs, AccessControlPolicySpecOidcStateCookiePtr and AccessControlPolicySpecOidcStateCookiePtrOutput values.
// You can construct a concrete instance of `AccessControlPolicySpecOidcStateCookiePtrInput` via:
//
//	        AccessControlPolicySpecOidcStateCookieArgs{...}
//
//	or:
//
//	        nil
type AccessControlPolicySpecOidcStateCookiePtrInput interface {
	pulumi.Input

	ToAccessControlPolicySpecOidcStateCookiePtrOutput() AccessControlPolicySpecOidcStateCookiePtrOutput
	ToAccessControlPolicySpecOidcStateCookiePtrOutputWithContext(context.Context) AccessControlPolicySpecOidcStateCookiePtrOutput
}

type accessControlPolicySpecOidcStateCookiePtrType AccessControlPolicySpecOidcStateCookieArgs

func AccessControlPolicySpecOidcStateCookiePtr(v *AccessControlPolicySpecOidcStateCookieArgs) AccessControlPolicySpecOidcStateCookiePtrInput {
	return (*accessControlPolicySpecOidcStateCookiePtrType)(v)
}

func (*accessControlPolicySpecOidcStateCookiePtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecOidcStateCookie)(nil)).Elem()
}

func (i *accessControlPolicySpecOidcStateCookiePtrType) ToAccessControlPolicySpecOidcStateCookiePtrOutput() AccessControlPolicySpecOidcStateCookiePtrOutput {
	return i.ToAccessControlPolicySpecOidcStateCookiePtrOutputWithContext(context.Background())
}

func (i *accessControlPolicySpecOidcStateCookiePtrType) ToAccessControlPolicySpecOidcStateCookiePtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcStateCookiePtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicySpecOidcStateCookiePtrOutput)
}

func (i *accessControlPolicySpecOidcStateCookiePtrType) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecOidcStateCookie] {
	return pulumix.Output[*AccessControlPolicySpecOidcStateCookie]{
		OutputState: i.ToAccessControlPolicySpecOidcStateCookiePtrOutputWithContext(ctx).OutputState,
	}
}

// StateCookie holds state cookie configuration.
type AccessControlPolicySpecOidcStateCookieOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecOidcStateCookieOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicySpecOidcStateCookie)(nil)).Elem()
}

func (o AccessControlPolicySpecOidcStateCookieOutput) ToAccessControlPolicySpecOidcStateCookieOutput() AccessControlPolicySpecOidcStateCookieOutput {
	return o
}

func (o AccessControlPolicySpecOidcStateCookieOutput) ToAccessControlPolicySpecOidcStateCookieOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcStateCookieOutput {
	return o
}

func (o AccessControlPolicySpecOidcStateCookieOutput) ToAccessControlPolicySpecOidcStateCookiePtrOutput() AccessControlPolicySpecOidcStateCookiePtrOutput {
	return o.ToAccessControlPolicySpecOidcStateCookiePtrOutputWithContext(context.Background())
}

func (o AccessControlPolicySpecOidcStateCookieOutput) ToAccessControlPolicySpecOidcStateCookiePtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcStateCookiePtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v AccessControlPolicySpecOidcStateCookie) *AccessControlPolicySpecOidcStateCookie {
		return &v
	}).(AccessControlPolicySpecOidcStateCookiePtrOutput)
}

func (o AccessControlPolicySpecOidcStateCookieOutput) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicySpecOidcStateCookie] {
	return pulumix.Output[AccessControlPolicySpecOidcStateCookie]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicySpecOidcStateCookieOutput) Domain() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcStateCookie) *string { return v.Domain }).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcStateCookieOutput) Path() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcStateCookie) *string { return v.Path }).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcStateCookieOutput) SameSite() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcStateCookie) *string { return v.SameSite }).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcStateCookieOutput) Secure() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v AccessControlPolicySpecOidcStateCookie) *bool { return v.Secure }).(pulumi.BoolPtrOutput)
}

type AccessControlPolicySpecOidcStateCookiePtrOutput struct{ *pulumi.OutputState }

func (AccessControlPolicySpecOidcStateCookiePtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicySpecOidcStateCookie)(nil)).Elem()
}

func (o AccessControlPolicySpecOidcStateCookiePtrOutput) ToAccessControlPolicySpecOidcStateCookiePtrOutput() AccessControlPolicySpecOidcStateCookiePtrOutput {
	return o
}

func (o AccessControlPolicySpecOidcStateCookiePtrOutput) ToAccessControlPolicySpecOidcStateCookiePtrOutputWithContext(ctx context.Context) AccessControlPolicySpecOidcStateCookiePtrOutput {
	return o
}

func (o AccessControlPolicySpecOidcStateCookiePtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicySpecOidcStateCookie] {
	return pulumix.Output[*AccessControlPolicySpecOidcStateCookie]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicySpecOidcStateCookiePtrOutput) Elem() AccessControlPolicySpecOidcStateCookieOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcStateCookie) AccessControlPolicySpecOidcStateCookie {
		if v != nil {
			return *v
		}
		var ret AccessControlPolicySpecOidcStateCookie
		return ret
	}).(AccessControlPolicySpecOidcStateCookieOutput)
}

func (o AccessControlPolicySpecOidcStateCookiePtrOutput) Domain() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcStateCookie) *string {
		if v == nil {
			return nil
		}
		return v.Domain
	}).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcStateCookiePtrOutput) Path() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcStateCookie) *string {
		if v == nil {
			return nil
		}
		return v.Path
	}).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcStateCookiePtrOutput) SameSite() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcStateCookie) *string {
		if v == nil {
			return nil
		}
		return v.SameSite
	}).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicySpecOidcStateCookiePtrOutput) Secure() pulumi.BoolPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicySpecOidcStateCookie) *bool {
		if v == nil {
			return nil
		}
		return v.Secure
	}).(pulumi.BoolPtrOutput)
}

// The current status of this access control policy.
type AccessControlPolicyStatus struct {
	SpecHash *string `pulumi:"specHash"`
	SyncedAt *string `pulumi:"syncedAt"`
	Version  *string `pulumi:"version"`
}

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

	ToAccessControlPolicyStatusOutput() AccessControlPolicyStatusOutput
	ToAccessControlPolicyStatusOutputWithContext(context.Context) AccessControlPolicyStatusOutput
}

// The current status of this access control policy.
type AccessControlPolicyStatusArgs struct {
	SpecHash pulumi.StringPtrInput `pulumi:"specHash"`
	SyncedAt pulumi.StringPtrInput `pulumi:"syncedAt"`
	Version  pulumi.StringPtrInput `pulumi:"version"`
}

func (AccessControlPolicyStatusArgs) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicyStatus)(nil)).Elem()
}

func (i AccessControlPolicyStatusArgs) ToAccessControlPolicyStatusOutput() AccessControlPolicyStatusOutput {
	return i.ToAccessControlPolicyStatusOutputWithContext(context.Background())
}

func (i AccessControlPolicyStatusArgs) ToAccessControlPolicyStatusOutputWithContext(ctx context.Context) AccessControlPolicyStatusOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicyStatusOutput)
}

func (i AccessControlPolicyStatusArgs) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicyStatus] {
	return pulumix.Output[AccessControlPolicyStatus]{
		OutputState: i.ToAccessControlPolicyStatusOutputWithContext(ctx).OutputState,
	}
}

func (i AccessControlPolicyStatusArgs) ToAccessControlPolicyStatusPtrOutput() AccessControlPolicyStatusPtrOutput {
	return i.ToAccessControlPolicyStatusPtrOutputWithContext(context.Background())
}

func (i AccessControlPolicyStatusArgs) ToAccessControlPolicyStatusPtrOutputWithContext(ctx context.Context) AccessControlPolicyStatusPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicyStatusOutput).ToAccessControlPolicyStatusPtrOutputWithContext(ctx)
}

// AccessControlPolicyStatusPtrInput is an input type that accepts AccessControlPolicyStatusArgs, AccessControlPolicyStatusPtr and AccessControlPolicyStatusPtrOutput values.
// You can construct a concrete instance of `AccessControlPolicyStatusPtrInput` via:
//
//	        AccessControlPolicyStatusArgs{...}
//
//	or:
//
//	        nil
type AccessControlPolicyStatusPtrInput interface {
	pulumi.Input

	ToAccessControlPolicyStatusPtrOutput() AccessControlPolicyStatusPtrOutput
	ToAccessControlPolicyStatusPtrOutputWithContext(context.Context) AccessControlPolicyStatusPtrOutput
}

type accessControlPolicyStatusPtrType AccessControlPolicyStatusArgs

func AccessControlPolicyStatusPtr(v *AccessControlPolicyStatusArgs) AccessControlPolicyStatusPtrInput {
	return (*accessControlPolicyStatusPtrType)(v)
}

func (*accessControlPolicyStatusPtrType) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicyStatus)(nil)).Elem()
}

func (i *accessControlPolicyStatusPtrType) ToAccessControlPolicyStatusPtrOutput() AccessControlPolicyStatusPtrOutput {
	return i.ToAccessControlPolicyStatusPtrOutputWithContext(context.Background())
}

func (i *accessControlPolicyStatusPtrType) ToAccessControlPolicyStatusPtrOutputWithContext(ctx context.Context) AccessControlPolicyStatusPtrOutput {
	return pulumi.ToOutputWithContext(ctx, i).(AccessControlPolicyStatusPtrOutput)
}

func (i *accessControlPolicyStatusPtrType) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicyStatus] {
	return pulumix.Output[*AccessControlPolicyStatus]{
		OutputState: i.ToAccessControlPolicyStatusPtrOutputWithContext(ctx).OutputState,
	}
}

// The current status of this access control policy.
type AccessControlPolicyStatusOutput struct{ *pulumi.OutputState }

func (AccessControlPolicyStatusOutput) ElementType() reflect.Type {
	return reflect.TypeOf((*AccessControlPolicyStatus)(nil)).Elem()
}

func (o AccessControlPolicyStatusOutput) ToAccessControlPolicyStatusOutput() AccessControlPolicyStatusOutput {
	return o
}

func (o AccessControlPolicyStatusOutput) ToAccessControlPolicyStatusOutputWithContext(ctx context.Context) AccessControlPolicyStatusOutput {
	return o
}

func (o AccessControlPolicyStatusOutput) ToAccessControlPolicyStatusPtrOutput() AccessControlPolicyStatusPtrOutput {
	return o.ToAccessControlPolicyStatusPtrOutputWithContext(context.Background())
}

func (o AccessControlPolicyStatusOutput) ToAccessControlPolicyStatusPtrOutputWithContext(ctx context.Context) AccessControlPolicyStatusPtrOutput {
	return o.ApplyTWithContext(ctx, func(_ context.Context, v AccessControlPolicyStatus) *AccessControlPolicyStatus {
		return &v
	}).(AccessControlPolicyStatusPtrOutput)
}

func (o AccessControlPolicyStatusOutput) ToOutput(ctx context.Context) pulumix.Output[AccessControlPolicyStatus] {
	return pulumix.Output[AccessControlPolicyStatus]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicyStatusOutput) SpecHash() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicyStatus) *string { return v.SpecHash }).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicyStatusOutput) SyncedAt() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicyStatus) *string { return v.SyncedAt }).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicyStatusOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v AccessControlPolicyStatus) *string { return v.Version }).(pulumi.StringPtrOutput)
}

type AccessControlPolicyStatusPtrOutput struct{ *pulumi.OutputState }

func (AccessControlPolicyStatusPtrOutput) ElementType() reflect.Type {
	return reflect.TypeOf((**AccessControlPolicyStatus)(nil)).Elem()
}

func (o AccessControlPolicyStatusPtrOutput) ToAccessControlPolicyStatusPtrOutput() AccessControlPolicyStatusPtrOutput {
	return o
}

func (o AccessControlPolicyStatusPtrOutput) ToAccessControlPolicyStatusPtrOutputWithContext(ctx context.Context) AccessControlPolicyStatusPtrOutput {
	return o
}

func (o AccessControlPolicyStatusPtrOutput) ToOutput(ctx context.Context) pulumix.Output[*AccessControlPolicyStatus] {
	return pulumix.Output[*AccessControlPolicyStatus]{
		OutputState: o.OutputState,
	}
}

func (o AccessControlPolicyStatusPtrOutput) Elem() AccessControlPolicyStatusOutput {
	return o.ApplyT(func(v *AccessControlPolicyStatus) AccessControlPolicyStatus {
		if v != nil {
			return *v
		}
		var ret AccessControlPolicyStatus
		return ret
	}).(AccessControlPolicyStatusOutput)
}

func (o AccessControlPolicyStatusPtrOutput) SpecHash() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicyStatus) *string {
		if v == nil {
			return nil
		}
		return v.SpecHash
	}).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicyStatusPtrOutput) SyncedAt() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicyStatus) *string {
		if v == nil {
			return nil
		}
		return v.SyncedAt
	}).(pulumi.StringPtrOutput)
}

func (o AccessControlPolicyStatusPtrOutput) Version() pulumi.StringPtrOutput {
	return o.ApplyT(func(v *AccessControlPolicyStatus) *string {
		if v == nil {
			return nil
		}
		return v.Version
	}).(pulumi.StringPtrOutput)
}

func init() {
	pulumi.RegisterInputType(reflect.TypeOf((*APIAccessSpecInput)(nil)).Elem(), APIAccessSpecArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIAccessSpecPtrInput)(nil)).Elem(), APIAccessSpecArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIAccessSpecApiSelectorInput)(nil)).Elem(), APIAccessSpecApiSelectorArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIAccessSpecApiSelectorPtrInput)(nil)).Elem(), APIAccessSpecApiSelectorArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIAccessSpecApiSelectorMatchExpressionsInput)(nil)).Elem(), APIAccessSpecApiSelectorMatchExpressionsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIAccessSpecApiSelectorMatchExpressionsArrayInput)(nil)).Elem(), APIAccessSpecApiSelectorMatchExpressionsArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIAccessSpecApisInput)(nil)).Elem(), APIAccessSpecApisArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIAccessSpecApisArrayInput)(nil)).Elem(), APIAccessSpecApisArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIAccessSpecOperationFilterInput)(nil)).Elem(), APIAccessSpecOperationFilterArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIAccessSpecOperationFilterPtrInput)(nil)).Elem(), APIAccessSpecOperationFilterArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIAccessStatusInput)(nil)).Elem(), APIAccessStatusArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIAccessStatusPtrInput)(nil)).Elem(), APIAccessStatusArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIPortalSpecInput)(nil)).Elem(), APIPortalSpecArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIPortalSpecPtrInput)(nil)).Elem(), APIPortalSpecArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIPortalSpecUiInput)(nil)).Elem(), APIPortalSpecUiArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIPortalSpecUiPtrInput)(nil)).Elem(), APIPortalSpecUiArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIPortalStatusInput)(nil)).Elem(), APIPortalStatusArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIPortalStatusPtrInput)(nil)).Elem(), APIPortalStatusArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIPortalStatusOidcInput)(nil)).Elem(), APIPortalStatusOidcArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIPortalStatusOidcPtrInput)(nil)).Elem(), APIPortalStatusOidcArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIRateLimitSpecInput)(nil)).Elem(), APIRateLimitSpecArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIRateLimitSpecPtrInput)(nil)).Elem(), APIRateLimitSpecArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIRateLimitSpecApiSelectorInput)(nil)).Elem(), APIRateLimitSpecApiSelectorArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIRateLimitSpecApiSelectorPtrInput)(nil)).Elem(), APIRateLimitSpecApiSelectorArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIRateLimitSpecApiSelectorMatchExpressionsInput)(nil)).Elem(), APIRateLimitSpecApiSelectorMatchExpressionsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIRateLimitSpecApiSelectorMatchExpressionsArrayInput)(nil)).Elem(), APIRateLimitSpecApiSelectorMatchExpressionsArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIRateLimitSpecApisInput)(nil)).Elem(), APIRateLimitSpecApisArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIRateLimitSpecApisArrayInput)(nil)).Elem(), APIRateLimitSpecApisArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIRateLimitStatusInput)(nil)).Elem(), APIRateLimitStatusArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIRateLimitStatusPtrInput)(nil)).Elem(), APIRateLimitStatusArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APISpecInput)(nil)).Elem(), APISpecArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APISpecPtrInput)(nil)).Elem(), APISpecArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APISpecOpenApiSpecInput)(nil)).Elem(), APISpecOpenApiSpecArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APISpecOpenApiSpecPtrInput)(nil)).Elem(), APISpecOpenApiSpecArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APISpecOpenApiSpecOperationSetsInput)(nil)).Elem(), APISpecOpenApiSpecOperationSetsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APISpecOpenApiSpecOperationSetsArrayInput)(nil)).Elem(), APISpecOpenApiSpecOperationSetsArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*APISpecOpenApiSpecOperationSetsMatchersInput)(nil)).Elem(), APISpecOpenApiSpecOperationSetsMatchersArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APISpecOpenApiSpecOperationSetsMatchersArrayInput)(nil)).Elem(), APISpecOpenApiSpecOperationSetsMatchersArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*APISpecOpenApiSpecOverrideInput)(nil)).Elem(), APISpecOpenApiSpecOverrideArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APISpecOpenApiSpecOverridePtrInput)(nil)).Elem(), APISpecOpenApiSpecOverrideArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APISpecOpenApiSpecOverrideServersInput)(nil)).Elem(), APISpecOpenApiSpecOverrideServersArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APISpecOpenApiSpecOverrideServersArrayInput)(nil)).Elem(), APISpecOpenApiSpecOverrideServersArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*APISpecVersionsInput)(nil)).Elem(), APISpecVersionsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APISpecVersionsArrayInput)(nil)).Elem(), APISpecVersionsArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIStatusInput)(nil)).Elem(), APIStatusArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIStatusPtrInput)(nil)).Elem(), APIStatusArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIVersionSpecInput)(nil)).Elem(), APIVersionSpecArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIVersionSpecPtrInput)(nil)).Elem(), APIVersionSpecArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIVersionSpecOpenApiSpecInput)(nil)).Elem(), APIVersionSpecOpenApiSpecArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIVersionSpecOpenApiSpecPtrInput)(nil)).Elem(), APIVersionSpecOpenApiSpecArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIVersionSpecOpenApiSpecOperationSetsInput)(nil)).Elem(), APIVersionSpecOpenApiSpecOperationSetsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIVersionSpecOpenApiSpecOperationSetsArrayInput)(nil)).Elem(), APIVersionSpecOpenApiSpecOperationSetsArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIVersionSpecOpenApiSpecOperationSetsMatchersInput)(nil)).Elem(), APIVersionSpecOpenApiSpecOperationSetsMatchersArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIVersionSpecOpenApiSpecOperationSetsMatchersArrayInput)(nil)).Elem(), APIVersionSpecOpenApiSpecOperationSetsMatchersArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIVersionSpecOpenApiSpecOverrideInput)(nil)).Elem(), APIVersionSpecOpenApiSpecOverrideArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIVersionSpecOpenApiSpecOverridePtrInput)(nil)).Elem(), APIVersionSpecOpenApiSpecOverrideArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIVersionSpecOpenApiSpecOverrideServersInput)(nil)).Elem(), APIVersionSpecOpenApiSpecOverrideServersArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIVersionSpecOpenApiSpecOverrideServersArrayInput)(nil)).Elem(), APIVersionSpecOpenApiSpecOverrideServersArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIVersionStatusInput)(nil)).Elem(), APIVersionStatusArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*APIVersionStatusPtrInput)(nil)).Elem(), APIVersionStatusArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecInput)(nil)).Elem(), AccessControlPolicySpecArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecPtrInput)(nil)).Elem(), AccessControlPolicySpecArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecApiKeyInput)(nil)).Elem(), AccessControlPolicySpecApiKeyArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecApiKeyPtrInput)(nil)).Elem(), AccessControlPolicySpecApiKeyArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecApiKeyKeySourceInput)(nil)).Elem(), AccessControlPolicySpecApiKeyKeySourceArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecApiKeyKeySourcePtrInput)(nil)).Elem(), AccessControlPolicySpecApiKeyKeySourceArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecApiKeyKeysInput)(nil)).Elem(), AccessControlPolicySpecApiKeyKeysArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecApiKeyKeysArrayInput)(nil)).Elem(), AccessControlPolicySpecApiKeyKeysArray{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecBasicAuthInput)(nil)).Elem(), AccessControlPolicySpecBasicAuthArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecBasicAuthPtrInput)(nil)).Elem(), AccessControlPolicySpecBasicAuthArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecJwtInput)(nil)).Elem(), AccessControlPolicySpecJwtArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecJwtPtrInput)(nil)).Elem(), AccessControlPolicySpecJwtArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecOAuthIntroInput)(nil)).Elem(), AccessControlPolicySpecOAuthIntroArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecOAuthIntroPtrInput)(nil)).Elem(), AccessControlPolicySpecOAuthIntroArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecOAuthIntroClientConfigInput)(nil)).Elem(), AccessControlPolicySpecOAuthIntroClientConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecOAuthIntroClientConfigPtrInput)(nil)).Elem(), AccessControlPolicySpecOAuthIntroClientConfigArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecOAuthIntroClientConfigTlsInput)(nil)).Elem(), AccessControlPolicySpecOAuthIntroClientConfigTlsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecOAuthIntroClientConfigTlsPtrInput)(nil)).Elem(), AccessControlPolicySpecOAuthIntroClientConfigTlsArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecOAuthIntroTokenSourceInput)(nil)).Elem(), AccessControlPolicySpecOAuthIntroTokenSourceArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecOAuthIntroTokenSourcePtrInput)(nil)).Elem(), AccessControlPolicySpecOAuthIntroTokenSourceArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecOidcInput)(nil)).Elem(), AccessControlPolicySpecOidcArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecOidcPtrInput)(nil)).Elem(), AccessControlPolicySpecOidcArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecOidcGoogleInput)(nil)).Elem(), AccessControlPolicySpecOidcGoogleArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecOidcGooglePtrInput)(nil)).Elem(), AccessControlPolicySpecOidcGoogleArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecOidcGoogleSecretInput)(nil)).Elem(), AccessControlPolicySpecOidcGoogleSecretArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecOidcGoogleSecretPtrInput)(nil)).Elem(), AccessControlPolicySpecOidcGoogleSecretArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecOidcGoogleSessionInput)(nil)).Elem(), AccessControlPolicySpecOidcGoogleSessionArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecOidcGoogleSessionPtrInput)(nil)).Elem(), AccessControlPolicySpecOidcGoogleSessionArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecOidcGoogleStateCookieInput)(nil)).Elem(), AccessControlPolicySpecOidcGoogleStateCookieArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecOidcGoogleStateCookiePtrInput)(nil)).Elem(), AccessControlPolicySpecOidcGoogleStateCookieArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecOidcSecretInput)(nil)).Elem(), AccessControlPolicySpecOidcSecretArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecOidcSecretPtrInput)(nil)).Elem(), AccessControlPolicySpecOidcSecretArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecOidcSessionInput)(nil)).Elem(), AccessControlPolicySpecOidcSessionArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecOidcSessionPtrInput)(nil)).Elem(), AccessControlPolicySpecOidcSessionArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecOidcStateCookieInput)(nil)).Elem(), AccessControlPolicySpecOidcStateCookieArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicySpecOidcStateCookiePtrInput)(nil)).Elem(), AccessControlPolicySpecOidcStateCookieArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicyStatusInput)(nil)).Elem(), AccessControlPolicyStatusArgs{})
	pulumi.RegisterInputType(reflect.TypeOf((*AccessControlPolicyStatusPtrInput)(nil)).Elem(), AccessControlPolicyStatusArgs{})
	pulumi.RegisterOutputType(APIAccessSpecOutput{})
	pulumi.RegisterOutputType(APIAccessSpecPtrOutput{})
	pulumi.RegisterOutputType(APIAccessSpecApiSelectorOutput{})
	pulumi.RegisterOutputType(APIAccessSpecApiSelectorPtrOutput{})
	pulumi.RegisterOutputType(APIAccessSpecApiSelectorMatchExpressionsOutput{})
	pulumi.RegisterOutputType(APIAccessSpecApiSelectorMatchExpressionsArrayOutput{})
	pulumi.RegisterOutputType(APIAccessSpecApisOutput{})
	pulumi.RegisterOutputType(APIAccessSpecApisArrayOutput{})
	pulumi.RegisterOutputType(APIAccessSpecOperationFilterOutput{})
	pulumi.RegisterOutputType(APIAccessSpecOperationFilterPtrOutput{})
	pulumi.RegisterOutputType(APIAccessStatusOutput{})
	pulumi.RegisterOutputType(APIAccessStatusPtrOutput{})
	pulumi.RegisterOutputType(APIPortalSpecOutput{})
	pulumi.RegisterOutputType(APIPortalSpecPtrOutput{})
	pulumi.RegisterOutputType(APIPortalSpecUiOutput{})
	pulumi.RegisterOutputType(APIPortalSpecUiPtrOutput{})
	pulumi.RegisterOutputType(APIPortalStatusOutput{})
	pulumi.RegisterOutputType(APIPortalStatusPtrOutput{})
	pulumi.RegisterOutputType(APIPortalStatusOidcOutput{})
	pulumi.RegisterOutputType(APIPortalStatusOidcPtrOutput{})
	pulumi.RegisterOutputType(APIRateLimitSpecOutput{})
	pulumi.RegisterOutputType(APIRateLimitSpecPtrOutput{})
	pulumi.RegisterOutputType(APIRateLimitSpecApiSelectorOutput{})
	pulumi.RegisterOutputType(APIRateLimitSpecApiSelectorPtrOutput{})
	pulumi.RegisterOutputType(APIRateLimitSpecApiSelectorMatchExpressionsOutput{})
	pulumi.RegisterOutputType(APIRateLimitSpecApiSelectorMatchExpressionsArrayOutput{})
	pulumi.RegisterOutputType(APIRateLimitSpecApisOutput{})
	pulumi.RegisterOutputType(APIRateLimitSpecApisArrayOutput{})
	pulumi.RegisterOutputType(APIRateLimitStatusOutput{})
	pulumi.RegisterOutputType(APIRateLimitStatusPtrOutput{})
	pulumi.RegisterOutputType(APISpecOutput{})
	pulumi.RegisterOutputType(APISpecPtrOutput{})
	pulumi.RegisterOutputType(APISpecOpenApiSpecOutput{})
	pulumi.RegisterOutputType(APISpecOpenApiSpecPtrOutput{})
	pulumi.RegisterOutputType(APISpecOpenApiSpecOperationSetsOutput{})
	pulumi.RegisterOutputType(APISpecOpenApiSpecOperationSetsArrayOutput{})
	pulumi.RegisterOutputType(APISpecOpenApiSpecOperationSetsMatchersOutput{})
	pulumi.RegisterOutputType(APISpecOpenApiSpecOperationSetsMatchersArrayOutput{})
	pulumi.RegisterOutputType(APISpecOpenApiSpecOverrideOutput{})
	pulumi.RegisterOutputType(APISpecOpenApiSpecOverridePtrOutput{})
	pulumi.RegisterOutputType(APISpecOpenApiSpecOverrideServersOutput{})
	pulumi.RegisterOutputType(APISpecOpenApiSpecOverrideServersArrayOutput{})
	pulumi.RegisterOutputType(APISpecVersionsOutput{})
	pulumi.RegisterOutputType(APISpecVersionsArrayOutput{})
	pulumi.RegisterOutputType(APIStatusOutput{})
	pulumi.RegisterOutputType(APIStatusPtrOutput{})
	pulumi.RegisterOutputType(APIVersionSpecOutput{})
	pulumi.RegisterOutputType(APIVersionSpecPtrOutput{})
	pulumi.RegisterOutputType(APIVersionSpecOpenApiSpecOutput{})
	pulumi.RegisterOutputType(APIVersionSpecOpenApiSpecPtrOutput{})
	pulumi.RegisterOutputType(APIVersionSpecOpenApiSpecOperationSetsOutput{})
	pulumi.RegisterOutputType(APIVersionSpecOpenApiSpecOperationSetsArrayOutput{})
	pulumi.RegisterOutputType(APIVersionSpecOpenApiSpecOperationSetsMatchersOutput{})
	pulumi.RegisterOutputType(APIVersionSpecOpenApiSpecOperationSetsMatchersArrayOutput{})
	pulumi.RegisterOutputType(APIVersionSpecOpenApiSpecOverrideOutput{})
	pulumi.RegisterOutputType(APIVersionSpecOpenApiSpecOverridePtrOutput{})
	pulumi.RegisterOutputType(APIVersionSpecOpenApiSpecOverrideServersOutput{})
	pulumi.RegisterOutputType(APIVersionSpecOpenApiSpecOverrideServersArrayOutput{})
	pulumi.RegisterOutputType(APIVersionStatusOutput{})
	pulumi.RegisterOutputType(APIVersionStatusPtrOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecPtrOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecApiKeyOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecApiKeyPtrOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecApiKeyKeySourceOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecApiKeyKeySourcePtrOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecApiKeyKeysOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecApiKeyKeysArrayOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecBasicAuthOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecBasicAuthPtrOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecJwtOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecJwtPtrOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecOAuthIntroOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecOAuthIntroPtrOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecOAuthIntroClientConfigOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecOAuthIntroClientConfigPtrOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecOAuthIntroClientConfigTlsOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecOAuthIntroClientConfigTlsPtrOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecOAuthIntroTokenSourceOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecOAuthIntroTokenSourcePtrOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecOidcOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecOidcPtrOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecOidcGoogleOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecOidcGooglePtrOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecOidcGoogleSecretOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecOidcGoogleSecretPtrOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecOidcGoogleSessionOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecOidcGoogleSessionPtrOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecOidcGoogleStateCookieOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecOidcGoogleStateCookiePtrOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecOidcSecretOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecOidcSecretPtrOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecOidcSessionOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecOidcSessionPtrOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecOidcStateCookieOutput{})
	pulumi.RegisterOutputType(AccessControlPolicySpecOidcStateCookiePtrOutput{})
	pulumi.RegisterOutputType(AccessControlPolicyStatusOutput{})
	pulumi.RegisterOutputType(AccessControlPolicyStatusPtrOutput{})
}
