alpha

package
v1.84.0 Latest Latest
Warning

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

 Go to latest Published: Feb 12, 2026 License: Apache-2.0 Imports: 12 Imported by: 0

Documentation

Overview

Copyright 2026 Google LLC. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2026 Google LLC. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2026 Google LLC. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2026 Google LLC. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2026 Google LLC. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2026 Google LLC. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2026 Google LLC. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2026 Google LLC. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2026 Google LLC. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2026 Google LLC. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2026 Google LLC. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2026 Google LLC. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2026 Google LLC. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2026 Google LLC. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2026 Google LLC. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2026 Google LLC. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.

Copyright 2026 Google LLC. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Package alpha defines operations in the declarative SDK.

Copyright 2026 Google LLC. All Rights Reserved.

Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at 

http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Package privateca contains methods and objects for handling privateca GCP resources.

Index

Constants

View Source 
const CaPoolMaxPage = -1
View Source 
const CertificateAuthorityMaxPage = -1
View Source 
const CertificateMaxPage = -1
View Source 
const CertificateTemplateMaxPage = -1

Variables

View Source 
var YAML_ca_pool []byte
View Source 
var YAML_certificate []byte
View Source 
var YAML_certificate_authority []byte
View Source 
var YAML_certificate_template []byte

Functions

func DCLCaPoolSchema added in v1.10.3 

func DCLCaPoolSchema() *dcl.Schema

func DCLCertificateAuthoritySchema added in v1.10.3 

func DCLCertificateAuthoritySchema() *dcl.Schema

func DCLCertificateSchema added in v1.10.3 

func DCLCertificateSchema() *dcl.Schema

func DCLCertificateTemplateSchema added in v1.10.3 

func DCLCertificateTemplateSchema() *dcl.Schema

Types

type CaPool 

type CaPool struct {
	Name              *string                  `json:"name"`
	Tier              *CaPoolTierEnum          `json:"tier"`
	IssuancePolicy    *CaPoolIssuancePolicy    `json:"issuancePolicy"`
	PublishingOptions *CaPoolPublishingOptions `json:"publishingOptions"`
	Labels            map[string]string        `json:"labels"`
	Project           *string                  `json:"project"`
	Location          *string                  `json:"location"`
}

func (*CaPool) Describe 

func (r *CaPool) Describe() dcl.ServiceTypeVersion

Describe returns a simple description of this resource to ensure that automated tools can identify it.

func (*CaPool) ID 

func (r *CaPool) ID() (string, error)

func (*CaPool) String 

func (r *CaPool) String() string

type CaPoolIssuancePolicy 

type CaPoolIssuancePolicy struct {
	AllowedKeyTypes       []CaPoolIssuancePolicyAllowedKeyTypes      `json:"allowedKeyTypes"`
	MaximumLifetime       *string                                    `json:"maximumLifetime"`
	AllowedIssuanceModes  *CaPoolIssuancePolicyAllowedIssuanceModes  `json:"allowedIssuanceModes"`
	BaselineValues        *CaPoolIssuancePolicyBaselineValues        `json:"baselineValues"`
	IdentityConstraints   *CaPoolIssuancePolicyIdentityConstraints   `json:"identityConstraints"`
	PassthroughExtensions *CaPoolIssuancePolicyPassthroughExtensions `json:"passthroughExtensions"`
	// contains filtered or unexported fields
}
var EmptyCaPoolIssuancePolicy *CaPoolIssuancePolicy = &CaPoolIssuancePolicy{empty: true}

This object is used to assert a desired state where this CaPoolIssuancePolicy is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CaPoolIssuancePolicy) Empty 

func (r *CaPoolIssuancePolicy) Empty() bool

func (*CaPoolIssuancePolicy) HashCode 

func (r *CaPoolIssuancePolicy) HashCode() string

func (*CaPoolIssuancePolicy) String 

func (r *CaPoolIssuancePolicy) String() string

func (*CaPoolIssuancePolicy) UnmarshalJSON 

func (r *CaPoolIssuancePolicy) UnmarshalJSON(data []byte) error

type CaPoolIssuancePolicyAllowedIssuanceModes 

type CaPoolIssuancePolicyAllowedIssuanceModes struct {
	AllowCsrBasedIssuance    *bool `json:"allowCsrBasedIssuance"`
	AllowConfigBasedIssuance *bool `json:"allowConfigBasedIssuance"`
	// contains filtered or unexported fields
}
var EmptyCaPoolIssuancePolicyAllowedIssuanceModes *CaPoolIssuancePolicyAllowedIssuanceModes = &CaPoolIssuancePolicyAllowedIssuanceModes{empty: true}

This object is used to assert a desired state where this CaPoolIssuancePolicyAllowedIssuanceModes is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CaPoolIssuancePolicyAllowedIssuanceModes) Empty 

func (r *CaPoolIssuancePolicyAllowedIssuanceModes) Empty() bool

func (*CaPoolIssuancePolicyAllowedIssuanceModes) HashCode 

func (r *CaPoolIssuancePolicyAllowedIssuanceModes) HashCode() string

func (*CaPoolIssuancePolicyAllowedIssuanceModes) String 

func (r *CaPoolIssuancePolicyAllowedIssuanceModes) String() string

func (*CaPoolIssuancePolicyAllowedIssuanceModes) UnmarshalJSON 

func (r *CaPoolIssuancePolicyAllowedIssuanceModes) UnmarshalJSON(data []byte) error

type CaPoolIssuancePolicyAllowedKeyTypes 

type CaPoolIssuancePolicyAllowedKeyTypes struct {
	Rsa           *CaPoolIssuancePolicyAllowedKeyTypesRsa           `json:"rsa"`
	EllipticCurve *CaPoolIssuancePolicyAllowedKeyTypesEllipticCurve `json:"ellipticCurve"`
	// contains filtered or unexported fields
}
var EmptyCaPoolIssuancePolicyAllowedKeyTypes *CaPoolIssuancePolicyAllowedKeyTypes = &CaPoolIssuancePolicyAllowedKeyTypes{empty: true}

This object is used to assert a desired state where this CaPoolIssuancePolicyAllowedKeyTypes is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CaPoolIssuancePolicyAllowedKeyTypes) Empty 

func (r *CaPoolIssuancePolicyAllowedKeyTypes) Empty() bool

func (*CaPoolIssuancePolicyAllowedKeyTypes) HashCode 

func (r *CaPoolIssuancePolicyAllowedKeyTypes) HashCode() string

func (*CaPoolIssuancePolicyAllowedKeyTypes) String 

func (r *CaPoolIssuancePolicyAllowedKeyTypes) String() string

func (*CaPoolIssuancePolicyAllowedKeyTypes) UnmarshalJSON 

func (r *CaPoolIssuancePolicyAllowedKeyTypes) UnmarshalJSON(data []byte) error

type CaPoolIssuancePolicyAllowedKeyTypesEllipticCurve 

type CaPoolIssuancePolicyAllowedKeyTypesEllipticCurve struct {
	SignatureAlgorithm *CaPoolIssuancePolicyAllowedKeyTypesEllipticCurveSignatureAlgorithmEnum `json:"signatureAlgorithm"`
	// contains filtered or unexported fields
}
var EmptyCaPoolIssuancePolicyAllowedKeyTypesEllipticCurve *CaPoolIssuancePolicyAllowedKeyTypesEllipticCurve = &CaPoolIssuancePolicyAllowedKeyTypesEllipticCurve{empty: true}

This object is used to assert a desired state where this CaPoolIssuancePolicyAllowedKeyTypesEllipticCurve is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CaPoolIssuancePolicyAllowedKeyTypesEllipticCurve) Empty 

func (r *CaPoolIssuancePolicyAllowedKeyTypesEllipticCurve) Empty() bool

func (*CaPoolIssuancePolicyAllowedKeyTypesEllipticCurve) HashCode 

func (r *CaPoolIssuancePolicyAllowedKeyTypesEllipticCurve) HashCode() string

func (*CaPoolIssuancePolicyAllowedKeyTypesEllipticCurve) String 

func (r *CaPoolIssuancePolicyAllowedKeyTypesEllipticCurve) String() string

func (*CaPoolIssuancePolicyAllowedKeyTypesEllipticCurve) UnmarshalJSON 

func (r *CaPoolIssuancePolicyAllowedKeyTypesEllipticCurve) UnmarshalJSON(data []byte) error

type CaPoolIssuancePolicyAllowedKeyTypesEllipticCurveSignatureAlgorithmEnum 

type CaPoolIssuancePolicyAllowedKeyTypesEllipticCurveSignatureAlgorithmEnum string

The enum CaPoolIssuancePolicyAllowedKeyTypesEllipticCurveSignatureAlgorithmEnum.

func CaPoolIssuancePolicyAllowedKeyTypesEllipticCurveSignatureAlgorithmEnumRef 

func CaPoolIssuancePolicyAllowedKeyTypesEllipticCurveSignatureAlgorithmEnumRef(s string) *CaPoolIssuancePolicyAllowedKeyTypesEllipticCurveSignatureAlgorithmEnum

CaPoolIssuancePolicyAllowedKeyTypesEllipticCurveSignatureAlgorithmEnumRef returns a *CaPoolIssuancePolicyAllowedKeyTypesEllipticCurveSignatureAlgorithmEnum with the value of string s If the empty string is provided, nil is returned.

func (CaPoolIssuancePolicyAllowedKeyTypesEllipticCurveSignatureAlgorithmEnum) Validate 

func (v CaPoolIssuancePolicyAllowedKeyTypesEllipticCurveSignatureAlgorithmEnum) Validate() error

type CaPoolIssuancePolicyAllowedKeyTypesRsa 

type CaPoolIssuancePolicyAllowedKeyTypesRsa struct {
	MinModulusSize *int64 `json:"minModulusSize"`
	MaxModulusSize *int64 `json:"maxModulusSize"`
	// contains filtered or unexported fields
}
var EmptyCaPoolIssuancePolicyAllowedKeyTypesRsa *CaPoolIssuancePolicyAllowedKeyTypesRsa = &CaPoolIssuancePolicyAllowedKeyTypesRsa{empty: true}

This object is used to assert a desired state where this CaPoolIssuancePolicyAllowedKeyTypesRsa is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CaPoolIssuancePolicyAllowedKeyTypesRsa) Empty 

func (r *CaPoolIssuancePolicyAllowedKeyTypesRsa) Empty() bool

func (*CaPoolIssuancePolicyAllowedKeyTypesRsa) HashCode 

func (r *CaPoolIssuancePolicyAllowedKeyTypesRsa) HashCode() string

func (*CaPoolIssuancePolicyAllowedKeyTypesRsa) String 

func (r *CaPoolIssuancePolicyAllowedKeyTypesRsa) String() string

func (*CaPoolIssuancePolicyAllowedKeyTypesRsa) UnmarshalJSON 

func (r *CaPoolIssuancePolicyAllowedKeyTypesRsa) UnmarshalJSON(data []byte) error

type CaPoolIssuancePolicyBaselineValues 

type CaPoolIssuancePolicyBaselineValues struct {
	KeyUsage             *CaPoolIssuancePolicyBaselineValuesKeyUsage              `json:"keyUsage"`
	CaOptions            *CaPoolIssuancePolicyBaselineValuesCaOptions             `json:"caOptions"`
	PolicyIds            []CaPoolIssuancePolicyBaselineValuesPolicyIds            `json:"policyIds"`
	AiaOcspServers       []string                                                 `json:"aiaOcspServers"`
	AdditionalExtensions []CaPoolIssuancePolicyBaselineValuesAdditionalExtensions `json:"additionalExtensions"`
	// contains filtered or unexported fields
}
var EmptyCaPoolIssuancePolicyBaselineValues *CaPoolIssuancePolicyBaselineValues = &CaPoolIssuancePolicyBaselineValues{empty: true}

This object is used to assert a desired state where this CaPoolIssuancePolicyBaselineValues is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CaPoolIssuancePolicyBaselineValues) Empty 

func (r *CaPoolIssuancePolicyBaselineValues) Empty() bool

func (*CaPoolIssuancePolicyBaselineValues) HashCode 

func (r *CaPoolIssuancePolicyBaselineValues) HashCode() string

func (*CaPoolIssuancePolicyBaselineValues) String 

func (r *CaPoolIssuancePolicyBaselineValues) String() string

func (*CaPoolIssuancePolicyBaselineValues) UnmarshalJSON 

func (r *CaPoolIssuancePolicyBaselineValues) UnmarshalJSON(data []byte) error

type CaPoolIssuancePolicyBaselineValuesAdditionalExtensions 

type CaPoolIssuancePolicyBaselineValuesAdditionalExtensions struct {
	ObjectId *CaPoolIssuancePolicyBaselineValuesAdditionalExtensionsObjectId `json:"objectId"`
	Critical *bool                                                           `json:"critical"`
	Value    *string                                                         `json:"value"`
	// contains filtered or unexported fields
}
var EmptyCaPoolIssuancePolicyBaselineValuesAdditionalExtensions *CaPoolIssuancePolicyBaselineValuesAdditionalExtensions = &CaPoolIssuancePolicyBaselineValuesAdditionalExtensions{empty: true}

This object is used to assert a desired state where this CaPoolIssuancePolicyBaselineValuesAdditionalExtensions is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CaPoolIssuancePolicyBaselineValuesAdditionalExtensions) Empty 

func (r *CaPoolIssuancePolicyBaselineValuesAdditionalExtensions) Empty() bool

func (*CaPoolIssuancePolicyBaselineValuesAdditionalExtensions) HashCode 

func (r *CaPoolIssuancePolicyBaselineValuesAdditionalExtensions) HashCode() string

func (*CaPoolIssuancePolicyBaselineValuesAdditionalExtensions) String 

func (r *CaPoolIssuancePolicyBaselineValuesAdditionalExtensions) String() string

func (*CaPoolIssuancePolicyBaselineValuesAdditionalExtensions) UnmarshalJSON 

func (r *CaPoolIssuancePolicyBaselineValuesAdditionalExtensions) UnmarshalJSON(data []byte) error

type CaPoolIssuancePolicyBaselineValuesAdditionalExtensionsObjectId 

type CaPoolIssuancePolicyBaselineValuesAdditionalExtensionsObjectId struct {
	ObjectIdPath []int64 `json:"objectIdPath"`
	// contains filtered or unexported fields
}
var EmptyCaPoolIssuancePolicyBaselineValuesAdditionalExtensionsObjectId *CaPoolIssuancePolicyBaselineValuesAdditionalExtensionsObjectId = &CaPoolIssuancePolicyBaselineValuesAdditionalExtensionsObjectId{empty: true}

This object is used to assert a desired state where this CaPoolIssuancePolicyBaselineValuesAdditionalExtensionsObjectId is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CaPoolIssuancePolicyBaselineValuesAdditionalExtensionsObjectId) Empty 

func (r *CaPoolIssuancePolicyBaselineValuesAdditionalExtensionsObjectId) Empty() bool

func (*CaPoolIssuancePolicyBaselineValuesAdditionalExtensionsObjectId) HashCode 

func (r *CaPoolIssuancePolicyBaselineValuesAdditionalExtensionsObjectId) HashCode() string

func (*CaPoolIssuancePolicyBaselineValuesAdditionalExtensionsObjectId) String 

func (r *CaPoolIssuancePolicyBaselineValuesAdditionalExtensionsObjectId) String() string

func (*CaPoolIssuancePolicyBaselineValuesAdditionalExtensionsObjectId) UnmarshalJSON 

func (r *CaPoolIssuancePolicyBaselineValuesAdditionalExtensionsObjectId) UnmarshalJSON(data []byte) error

type CaPoolIssuancePolicyBaselineValuesCaOptions 

type CaPoolIssuancePolicyBaselineValuesCaOptions struct {
	IsCa                    *bool  `json:"isCa"`
	MaxIssuerPathLength     *int64 `json:"maxIssuerPathLength"`
	ZeroMaxIssuerPathLength *bool  `json:"zeroMaxIssuerPathLength"`
	// contains filtered or unexported fields
}
var EmptyCaPoolIssuancePolicyBaselineValuesCaOptions *CaPoolIssuancePolicyBaselineValuesCaOptions = &CaPoolIssuancePolicyBaselineValuesCaOptions{empty: true}

This object is used to assert a desired state where this CaPoolIssuancePolicyBaselineValuesCaOptions is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CaPoolIssuancePolicyBaselineValuesCaOptions) Empty 

func (r *CaPoolIssuancePolicyBaselineValuesCaOptions) Empty() bool

func (*CaPoolIssuancePolicyBaselineValuesCaOptions) HashCode 

func (r *CaPoolIssuancePolicyBaselineValuesCaOptions) HashCode() string

func (*CaPoolIssuancePolicyBaselineValuesCaOptions) String 

func (r *CaPoolIssuancePolicyBaselineValuesCaOptions) String() string

func (*CaPoolIssuancePolicyBaselineValuesCaOptions) UnmarshalJSON 

func (r *CaPoolIssuancePolicyBaselineValuesCaOptions) UnmarshalJSON(data []byte) error

type CaPoolIssuancePolicyBaselineValuesKeyUsage 

type CaPoolIssuancePolicyBaselineValuesKeyUsage struct {
	BaseKeyUsage             *CaPoolIssuancePolicyBaselineValuesKeyUsageBaseKeyUsage              `json:"baseKeyUsage"`
	ExtendedKeyUsage         *CaPoolIssuancePolicyBaselineValuesKeyUsageExtendedKeyUsage          `json:"extendedKeyUsage"`
	UnknownExtendedKeyUsages []CaPoolIssuancePolicyBaselineValuesKeyUsageUnknownExtendedKeyUsages `json:"unknownExtendedKeyUsages"`
	// contains filtered or unexported fields
}
var EmptyCaPoolIssuancePolicyBaselineValuesKeyUsage *CaPoolIssuancePolicyBaselineValuesKeyUsage = &CaPoolIssuancePolicyBaselineValuesKeyUsage{empty: true}

This object is used to assert a desired state where this CaPoolIssuancePolicyBaselineValuesKeyUsage is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CaPoolIssuancePolicyBaselineValuesKeyUsage) Empty 

func (r *CaPoolIssuancePolicyBaselineValuesKeyUsage) Empty() bool

func (*CaPoolIssuancePolicyBaselineValuesKeyUsage) HashCode 

func (r *CaPoolIssuancePolicyBaselineValuesKeyUsage) HashCode() string

func (*CaPoolIssuancePolicyBaselineValuesKeyUsage) String 

func (r *CaPoolIssuancePolicyBaselineValuesKeyUsage) String() string

func (*CaPoolIssuancePolicyBaselineValuesKeyUsage) UnmarshalJSON 

func (r *CaPoolIssuancePolicyBaselineValuesKeyUsage) UnmarshalJSON(data []byte) error

type CaPoolIssuancePolicyBaselineValuesKeyUsageBaseKeyUsage 

type CaPoolIssuancePolicyBaselineValuesKeyUsageBaseKeyUsage struct {
	DigitalSignature  *bool `json:"digitalSignature"`
	ContentCommitment *bool `json:"contentCommitment"`
	KeyEncipherment   *bool `json:"keyEncipherment"`
	DataEncipherment  *bool `json:"dataEncipherment"`
	KeyAgreement      *bool `json:"keyAgreement"`
	CertSign          *bool `json:"certSign"`
	CrlSign           *bool `json:"crlSign"`
	EncipherOnly      *bool `json:"encipherOnly"`
	DecipherOnly      *bool `json:"decipherOnly"`
	// contains filtered or unexported fields
}
var EmptyCaPoolIssuancePolicyBaselineValuesKeyUsageBaseKeyUsage *CaPoolIssuancePolicyBaselineValuesKeyUsageBaseKeyUsage = &CaPoolIssuancePolicyBaselineValuesKeyUsageBaseKeyUsage{empty: true}

This object is used to assert a desired state where this CaPoolIssuancePolicyBaselineValuesKeyUsageBaseKeyUsage is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CaPoolIssuancePolicyBaselineValuesKeyUsageBaseKeyUsage) Empty 

func (r *CaPoolIssuancePolicyBaselineValuesKeyUsageBaseKeyUsage) Empty() bool

func (*CaPoolIssuancePolicyBaselineValuesKeyUsageBaseKeyUsage) HashCode 

func (r *CaPoolIssuancePolicyBaselineValuesKeyUsageBaseKeyUsage) HashCode() string

func (*CaPoolIssuancePolicyBaselineValuesKeyUsageBaseKeyUsage) String 

func (r *CaPoolIssuancePolicyBaselineValuesKeyUsageBaseKeyUsage) String() string

func (*CaPoolIssuancePolicyBaselineValuesKeyUsageBaseKeyUsage) UnmarshalJSON 

func (r *CaPoolIssuancePolicyBaselineValuesKeyUsageBaseKeyUsage) UnmarshalJSON(data []byte) error

type CaPoolIssuancePolicyBaselineValuesKeyUsageExtendedKeyUsage 

type CaPoolIssuancePolicyBaselineValuesKeyUsageExtendedKeyUsage struct {
	ServerAuth      *bool `json:"serverAuth"`
	ClientAuth      *bool `json:"clientAuth"`
	CodeSigning     *bool `json:"codeSigning"`
	EmailProtection *bool `json:"emailProtection"`
	TimeStamping    *bool `json:"timeStamping"`
	OcspSigning     *bool `json:"ocspSigning"`
	// contains filtered or unexported fields
}
var EmptyCaPoolIssuancePolicyBaselineValuesKeyUsageExtendedKeyUsage *CaPoolIssuancePolicyBaselineValuesKeyUsageExtendedKeyUsage = &CaPoolIssuancePolicyBaselineValuesKeyUsageExtendedKeyUsage{empty: true}

This object is used to assert a desired state where this CaPoolIssuancePolicyBaselineValuesKeyUsageExtendedKeyUsage is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CaPoolIssuancePolicyBaselineValuesKeyUsageExtendedKeyUsage) Empty 

func (r *CaPoolIssuancePolicyBaselineValuesKeyUsageExtendedKeyUsage) Empty() bool

func (*CaPoolIssuancePolicyBaselineValuesKeyUsageExtendedKeyUsage) HashCode 

func (r *CaPoolIssuancePolicyBaselineValuesKeyUsageExtendedKeyUsage) HashCode() string

func (*CaPoolIssuancePolicyBaselineValuesKeyUsageExtendedKeyUsage) String 

func (r *CaPoolIssuancePolicyBaselineValuesKeyUsageExtendedKeyUsage) String() string

func (*CaPoolIssuancePolicyBaselineValuesKeyUsageExtendedKeyUsage) UnmarshalJSON 

func (r *CaPoolIssuancePolicyBaselineValuesKeyUsageExtendedKeyUsage) UnmarshalJSON(data []byte) error

type CaPoolIssuancePolicyBaselineValuesKeyUsageUnknownExtendedKeyUsages 

type CaPoolIssuancePolicyBaselineValuesKeyUsageUnknownExtendedKeyUsages struct {
	ObjectIdPath []int64 `json:"objectIdPath"`
	// contains filtered or unexported fields
}
var EmptyCaPoolIssuancePolicyBaselineValuesKeyUsageUnknownExtendedKeyUsages *CaPoolIssuancePolicyBaselineValuesKeyUsageUnknownExtendedKeyUsages = &CaPoolIssuancePolicyBaselineValuesKeyUsageUnknownExtendedKeyUsages{empty: true}

This object is used to assert a desired state where this CaPoolIssuancePolicyBaselineValuesKeyUsageUnknownExtendedKeyUsages is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CaPoolIssuancePolicyBaselineValuesKeyUsageUnknownExtendedKeyUsages) Empty 

func (r *CaPoolIssuancePolicyBaselineValuesKeyUsageUnknownExtendedKeyUsages) Empty() bool

func (*CaPoolIssuancePolicyBaselineValuesKeyUsageUnknownExtendedKeyUsages) HashCode 

func (r *CaPoolIssuancePolicyBaselineValuesKeyUsageUnknownExtendedKeyUsages) HashCode() string

func (*CaPoolIssuancePolicyBaselineValuesKeyUsageUnknownExtendedKeyUsages) String 

func (r *CaPoolIssuancePolicyBaselineValuesKeyUsageUnknownExtendedKeyUsages) String() string

func (*CaPoolIssuancePolicyBaselineValuesKeyUsageUnknownExtendedKeyUsages) UnmarshalJSON 

func (r *CaPoolIssuancePolicyBaselineValuesKeyUsageUnknownExtendedKeyUsages) UnmarshalJSON(data []byte) error

type CaPoolIssuancePolicyBaselineValuesPolicyIds 

type CaPoolIssuancePolicyBaselineValuesPolicyIds struct {
	ObjectIdPath []int64 `json:"objectIdPath"`
	// contains filtered or unexported fields
}
var EmptyCaPoolIssuancePolicyBaselineValuesPolicyIds *CaPoolIssuancePolicyBaselineValuesPolicyIds = &CaPoolIssuancePolicyBaselineValuesPolicyIds{empty: true}

This object is used to assert a desired state where this CaPoolIssuancePolicyBaselineValuesPolicyIds is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CaPoolIssuancePolicyBaselineValuesPolicyIds) Empty 

func (r *CaPoolIssuancePolicyBaselineValuesPolicyIds) Empty() bool

func (*CaPoolIssuancePolicyBaselineValuesPolicyIds) HashCode 

func (r *CaPoolIssuancePolicyBaselineValuesPolicyIds) HashCode() string

func (*CaPoolIssuancePolicyBaselineValuesPolicyIds) String 

func (r *CaPoolIssuancePolicyBaselineValuesPolicyIds) String() string

func (*CaPoolIssuancePolicyBaselineValuesPolicyIds) UnmarshalJSON 

func (r *CaPoolIssuancePolicyBaselineValuesPolicyIds) UnmarshalJSON(data []byte) error

type CaPoolIssuancePolicyIdentityConstraints 

type CaPoolIssuancePolicyIdentityConstraints struct {
	CelExpression                   *CaPoolIssuancePolicyIdentityConstraintsCelExpression `json:"celExpression"`
	AllowSubjectPassthrough         *bool                                                 `json:"allowSubjectPassthrough"`
	AllowSubjectAltNamesPassthrough *bool                                                 `json:"allowSubjectAltNamesPassthrough"`
	// contains filtered or unexported fields
}
var EmptyCaPoolIssuancePolicyIdentityConstraints *CaPoolIssuancePolicyIdentityConstraints = &CaPoolIssuancePolicyIdentityConstraints{empty: true}

This object is used to assert a desired state where this CaPoolIssuancePolicyIdentityConstraints is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CaPoolIssuancePolicyIdentityConstraints) Empty 

func (r *CaPoolIssuancePolicyIdentityConstraints) Empty() bool

func (*CaPoolIssuancePolicyIdentityConstraints) HashCode 

func (r *CaPoolIssuancePolicyIdentityConstraints) HashCode() string

func (*CaPoolIssuancePolicyIdentityConstraints) String 

func (r *CaPoolIssuancePolicyIdentityConstraints) String() string

func (*CaPoolIssuancePolicyIdentityConstraints) UnmarshalJSON 

func (r *CaPoolIssuancePolicyIdentityConstraints) UnmarshalJSON(data []byte) error

type CaPoolIssuancePolicyIdentityConstraintsCelExpression 

type CaPoolIssuancePolicyIdentityConstraintsCelExpression struct {
	Expression  *string `json:"expression"`
	Title       *string `json:"title"`
	Description *string `json:"description"`
	Location    *string `json:"location"`
	// contains filtered or unexported fields
}
var EmptyCaPoolIssuancePolicyIdentityConstraintsCelExpression *CaPoolIssuancePolicyIdentityConstraintsCelExpression = &CaPoolIssuancePolicyIdentityConstraintsCelExpression{empty: true}

This object is used to assert a desired state where this CaPoolIssuancePolicyIdentityConstraintsCelExpression is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CaPoolIssuancePolicyIdentityConstraintsCelExpression) Empty 

func (r *CaPoolIssuancePolicyIdentityConstraintsCelExpression) Empty() bool

func (*CaPoolIssuancePolicyIdentityConstraintsCelExpression) HashCode 

func (r *CaPoolIssuancePolicyIdentityConstraintsCelExpression) HashCode() string

func (*CaPoolIssuancePolicyIdentityConstraintsCelExpression) String 

func (r *CaPoolIssuancePolicyIdentityConstraintsCelExpression) String() string

func (*CaPoolIssuancePolicyIdentityConstraintsCelExpression) UnmarshalJSON 

func (r *CaPoolIssuancePolicyIdentityConstraintsCelExpression) UnmarshalJSON(data []byte) error

type CaPoolIssuancePolicyPassthroughExtensions 

type CaPoolIssuancePolicyPassthroughExtensions struct {
	KnownExtensions      []CaPoolIssuancePolicyPassthroughExtensionsKnownExtensionsEnum  `json:"knownExtensions"`
	AdditionalExtensions []CaPoolIssuancePolicyPassthroughExtensionsAdditionalExtensions `json:"additionalExtensions"`
	// contains filtered or unexported fields
}
var EmptyCaPoolIssuancePolicyPassthroughExtensions *CaPoolIssuancePolicyPassthroughExtensions = &CaPoolIssuancePolicyPassthroughExtensions{empty: true}

This object is used to assert a desired state where this CaPoolIssuancePolicyPassthroughExtensions is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CaPoolIssuancePolicyPassthroughExtensions) Empty 

func (r *CaPoolIssuancePolicyPassthroughExtensions) Empty() bool

func (*CaPoolIssuancePolicyPassthroughExtensions) HashCode 

func (r *CaPoolIssuancePolicyPassthroughExtensions) HashCode() string

func (*CaPoolIssuancePolicyPassthroughExtensions) String 

func (r *CaPoolIssuancePolicyPassthroughExtensions) String() string

func (*CaPoolIssuancePolicyPassthroughExtensions) UnmarshalJSON 

func (r *CaPoolIssuancePolicyPassthroughExtensions) UnmarshalJSON(data []byte) error

type CaPoolIssuancePolicyPassthroughExtensionsAdditionalExtensions 

type CaPoolIssuancePolicyPassthroughExtensionsAdditionalExtensions struct {
	ObjectIdPath []int64 `json:"objectIdPath"`
	// contains filtered or unexported fields
}
var EmptyCaPoolIssuancePolicyPassthroughExtensionsAdditionalExtensions *CaPoolIssuancePolicyPassthroughExtensionsAdditionalExtensions = &CaPoolIssuancePolicyPassthroughExtensionsAdditionalExtensions{empty: true}

This object is used to assert a desired state where this CaPoolIssuancePolicyPassthroughExtensionsAdditionalExtensions is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CaPoolIssuancePolicyPassthroughExtensionsAdditionalExtensions) Empty 

func (r *CaPoolIssuancePolicyPassthroughExtensionsAdditionalExtensions) Empty() bool

func (*CaPoolIssuancePolicyPassthroughExtensionsAdditionalExtensions) HashCode 

func (r *CaPoolIssuancePolicyPassthroughExtensionsAdditionalExtensions) HashCode() string

func (*CaPoolIssuancePolicyPassthroughExtensionsAdditionalExtensions) String 

func (r *CaPoolIssuancePolicyPassthroughExtensionsAdditionalExtensions) String() string

func (*CaPoolIssuancePolicyPassthroughExtensionsAdditionalExtensions) UnmarshalJSON 

func (r *CaPoolIssuancePolicyPassthroughExtensionsAdditionalExtensions) UnmarshalJSON(data []byte) error

type CaPoolIssuancePolicyPassthroughExtensionsKnownExtensionsEnum 

type CaPoolIssuancePolicyPassthroughExtensionsKnownExtensionsEnum string

The enum CaPoolIssuancePolicyPassthroughExtensionsKnownExtensionsEnum.

func CaPoolIssuancePolicyPassthroughExtensionsKnownExtensionsEnumRef 

func CaPoolIssuancePolicyPassthroughExtensionsKnownExtensionsEnumRef(s string) *CaPoolIssuancePolicyPassthroughExtensionsKnownExtensionsEnum

CaPoolIssuancePolicyPassthroughExtensionsKnownExtensionsEnumRef returns a *CaPoolIssuancePolicyPassthroughExtensionsKnownExtensionsEnum with the value of string s If the empty string is provided, nil is returned.

func (CaPoolIssuancePolicyPassthroughExtensionsKnownExtensionsEnum) Validate 

func (v CaPoolIssuancePolicyPassthroughExtensionsKnownExtensionsEnum) Validate() error

type CaPoolList 

type CaPoolList struct {
	Items []*CaPool
	// contains filtered or unexported fields
}

func (*CaPoolList) HasNext 

func (l *CaPoolList) HasNext() bool

func (*CaPoolList) Next 

func (l *CaPoolList) Next(ctx context.Context, c *Client) error

type CaPoolPublishingOptions 

type CaPoolPublishingOptions struct {
	PublishCaCert *bool `json:"publishCaCert"`
	PublishCrl    *bool `json:"publishCrl"`
	// contains filtered or unexported fields
}
var EmptyCaPoolPublishingOptions *CaPoolPublishingOptions = &CaPoolPublishingOptions{empty: true}

This object is used to assert a desired state where this CaPoolPublishingOptions is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CaPoolPublishingOptions) Empty 

func (r *CaPoolPublishingOptions) Empty() bool

func (*CaPoolPublishingOptions) HashCode 

func (r *CaPoolPublishingOptions) HashCode() string

func (*CaPoolPublishingOptions) String 

func (r *CaPoolPublishingOptions) String() string

func (*CaPoolPublishingOptions) UnmarshalJSON 

func (r *CaPoolPublishingOptions) UnmarshalJSON(data []byte) error

type CaPoolTierEnum 

type CaPoolTierEnum string

The enum CaPoolTierEnum.

func CaPoolTierEnumRef 

func CaPoolTierEnumRef(s string) *CaPoolTierEnum

CaPoolTierEnumRef returns a *CaPoolTierEnum with the value of string s If the empty string is provided, nil is returned.

func (CaPoolTierEnum) Validate 

func (v CaPoolTierEnum) Validate() error

type Certificate 

type Certificate struct {
	Name                       *string                            `json:"name"`
	PemCsr                     *string                            `json:"pemCsr"`
	Config                     *CertificateConfig                 `json:"config"`
	IssuerCertificateAuthority *string                            `json:"issuerCertificateAuthority"`
	Lifetime                   *string                            `json:"lifetime"`
	CertificateTemplate        *string                            `json:"certificateTemplate"`
	SubjectMode                *CertificateSubjectModeEnum        `json:"subjectMode"`
	RevocationDetails          *CertificateRevocationDetails      `json:"revocationDetails"`
	PemCertificate             *string                            `json:"pemCertificate"`
	CertificateDescription     *CertificateCertificateDescription `json:"certificateDescription"`
	PemCertificateChain        []string                           `json:"pemCertificateChain"`
	CreateTime                 *string                            `json:"createTime"`
	UpdateTime                 *string                            `json:"updateTime"`
	Labels                     map[string]string                  `json:"labels"`
	Project                    *string                            `json:"project"`
	Location                   *string                            `json:"location"`
	CaPool                     *string                            `json:"caPool"`
	CertificateAuthority       *string                            `json:"certificateAuthority"`
}

func (*Certificate) Describe 

func (r *Certificate) Describe() dcl.ServiceTypeVersion

Describe returns a simple description of this resource to ensure that automated tools can identify it.

func (*Certificate) ID 

func (r *Certificate) ID() (string, error)

func (*Certificate) String 

func (r *Certificate) String() string

type CertificateAuthority 

type CertificateAuthority struct {
	Name                      *string                                         `json:"name"`
	Type                      *CertificateAuthorityTypeEnum                   `json:"type"`
	Config                    *CertificateAuthorityConfig                     `json:"config"`
	Lifetime                  *string                                         `json:"lifetime"`
	KeySpec                   *CertificateAuthorityKeySpec                    `json:"keySpec"`
	SubordinateConfig         *CertificateAuthoritySubordinateConfig          `json:"subordinateConfig"`
	Tier                      *CertificateAuthorityTierEnum                   `json:"tier"`
	State                     *CertificateAuthorityStateEnum                  `json:"state"`
	PemCaCertificates         []string                                        `json:"pemCaCertificates"`
	CaCertificateDescriptions []CertificateAuthorityCaCertificateDescriptions `json:"caCertificateDescriptions"`
	GcsBucket                 *string                                         `json:"gcsBucket"`
	AccessUrls                *CertificateAuthorityAccessUrls                 `json:"accessUrls"`
	CreateTime                *string                                         `json:"createTime"`
	UpdateTime                *string                                         `json:"updateTime"`
	DeleteTime                *string                                         `json:"deleteTime"`
	ExpireTime                *string                                         `json:"expireTime"`
	Labels                    map[string]string                               `json:"labels"`
	Project                   *string                                         `json:"project"`
	Location                  *string                                         `json:"location"`
	CaPool                    *string                                         `json:"caPool"`
}

func (*CertificateAuthority) Describe 

func (r *CertificateAuthority) Describe() dcl.ServiceTypeVersion

Describe returns a simple description of this resource to ensure that automated tools can identify it.

func (*CertificateAuthority) ID 

func (r *CertificateAuthority) ID() (string, error)

func (*CertificateAuthority) String 

func (r *CertificateAuthority) String() string

type CertificateAuthorityAccessUrls 

type CertificateAuthorityAccessUrls struct {
	CaCertificateAccessUrl *string  `json:"caCertificateAccessUrl"`
	CrlAccessUrls          []string `json:"crlAccessUrls"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityAccessUrls *CertificateAuthorityAccessUrls = &CertificateAuthorityAccessUrls{empty: true}

This object is used to assert a desired state where this CertificateAuthorityAccessUrls is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityAccessUrls) Empty 

func (r *CertificateAuthorityAccessUrls) Empty() bool

func (*CertificateAuthorityAccessUrls) HashCode 

func (r *CertificateAuthorityAccessUrls) HashCode() string

func (*CertificateAuthorityAccessUrls) String 

func (r *CertificateAuthorityAccessUrls) String() string

func (*CertificateAuthorityAccessUrls) UnmarshalJSON 

func (r *CertificateAuthorityAccessUrls) UnmarshalJSON(data []byte) error

type CertificateAuthorityCaCertificateDescriptions 

type CertificateAuthorityCaCertificateDescriptions struct {
	SubjectDescription        *CertificateAuthorityCaCertificateDescriptionsSubjectDescription `json:"subjectDescription"`
	X509Description           *CertificateAuthorityCaCertificateDescriptionsX509Description    `json:"x509Description"`
	PublicKey                 *CertificateAuthorityCaCertificateDescriptionsPublicKey          `json:"publicKey"`
	SubjectKeyId              *CertificateAuthorityCaCertificateDescriptionsSubjectKeyId       `json:"subjectKeyId"`
	AuthorityKeyId            *CertificateAuthorityCaCertificateDescriptionsAuthorityKeyId     `json:"authorityKeyId"`
	CrlDistributionPoints     []string                                                         `json:"crlDistributionPoints"`
	AiaIssuingCertificateUrls []string                                                         `json:"aiaIssuingCertificateUrls"`
	CertFingerprint           *CertificateAuthorityCaCertificateDescriptionsCertFingerprint    `json:"certFingerprint"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityCaCertificateDescriptions *CertificateAuthorityCaCertificateDescriptions = &CertificateAuthorityCaCertificateDescriptions{empty: true}

This object is used to assert a desired state where this CertificateAuthorityCaCertificateDescriptions is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityCaCertificateDescriptions) Empty 

func (r *CertificateAuthorityCaCertificateDescriptions) Empty() bool

func (*CertificateAuthorityCaCertificateDescriptions) HashCode 

func (r *CertificateAuthorityCaCertificateDescriptions) HashCode() string

func (*CertificateAuthorityCaCertificateDescriptions) String 

func (r *CertificateAuthorityCaCertificateDescriptions) String() string

func (*CertificateAuthorityCaCertificateDescriptions) UnmarshalJSON 

func (r *CertificateAuthorityCaCertificateDescriptions) UnmarshalJSON(data []byte) error

type CertificateAuthorityCaCertificateDescriptionsAuthorityKeyId 

type CertificateAuthorityCaCertificateDescriptionsAuthorityKeyId struct {
	KeyId *string `json:"keyId"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityCaCertificateDescriptionsAuthorityKeyId *CertificateAuthorityCaCertificateDescriptionsAuthorityKeyId = &CertificateAuthorityCaCertificateDescriptionsAuthorityKeyId{empty: true}

This object is used to assert a desired state where this CertificateAuthorityCaCertificateDescriptionsAuthorityKeyId is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityCaCertificateDescriptionsAuthorityKeyId) Empty 

func (r *CertificateAuthorityCaCertificateDescriptionsAuthorityKeyId) Empty() bool

func (*CertificateAuthorityCaCertificateDescriptionsAuthorityKeyId) HashCode 

func (r *CertificateAuthorityCaCertificateDescriptionsAuthorityKeyId) HashCode() string

func (*CertificateAuthorityCaCertificateDescriptionsAuthorityKeyId) String 

func (r *CertificateAuthorityCaCertificateDescriptionsAuthorityKeyId) String() string

func (*CertificateAuthorityCaCertificateDescriptionsAuthorityKeyId) UnmarshalJSON 

func (r *CertificateAuthorityCaCertificateDescriptionsAuthorityKeyId) UnmarshalJSON(data []byte) error

type CertificateAuthorityCaCertificateDescriptionsCertFingerprint 

type CertificateAuthorityCaCertificateDescriptionsCertFingerprint struct {
	Sha256Hash *string `json:"sha256Hash"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityCaCertificateDescriptionsCertFingerprint *CertificateAuthorityCaCertificateDescriptionsCertFingerprint = &CertificateAuthorityCaCertificateDescriptionsCertFingerprint{empty: true}

This object is used to assert a desired state where this CertificateAuthorityCaCertificateDescriptionsCertFingerprint is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityCaCertificateDescriptionsCertFingerprint) Empty 

func (r *CertificateAuthorityCaCertificateDescriptionsCertFingerprint) Empty() bool

func (*CertificateAuthorityCaCertificateDescriptionsCertFingerprint) HashCode 

func (r *CertificateAuthorityCaCertificateDescriptionsCertFingerprint) HashCode() string

func (*CertificateAuthorityCaCertificateDescriptionsCertFingerprint) String 

func (r *CertificateAuthorityCaCertificateDescriptionsCertFingerprint) String() string

func (*CertificateAuthorityCaCertificateDescriptionsCertFingerprint) UnmarshalJSON 

func (r *CertificateAuthorityCaCertificateDescriptionsCertFingerprint) UnmarshalJSON(data []byte) error

type CertificateAuthorityCaCertificateDescriptionsPublicKey 

type CertificateAuthorityCaCertificateDescriptionsPublicKey struct {
	Key    *string                                                           `json:"key"`
	Format *CertificateAuthorityCaCertificateDescriptionsPublicKeyFormatEnum `json:"format"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityCaCertificateDescriptionsPublicKey *CertificateAuthorityCaCertificateDescriptionsPublicKey = &CertificateAuthorityCaCertificateDescriptionsPublicKey{empty: true}

This object is used to assert a desired state where this CertificateAuthorityCaCertificateDescriptionsPublicKey is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityCaCertificateDescriptionsPublicKey) Empty 

func (r *CertificateAuthorityCaCertificateDescriptionsPublicKey) Empty() bool

func (*CertificateAuthorityCaCertificateDescriptionsPublicKey) HashCode 

func (r *CertificateAuthorityCaCertificateDescriptionsPublicKey) HashCode() string

func (*CertificateAuthorityCaCertificateDescriptionsPublicKey) String 

func (r *CertificateAuthorityCaCertificateDescriptionsPublicKey) String() string

func (*CertificateAuthorityCaCertificateDescriptionsPublicKey) UnmarshalJSON 

func (r *CertificateAuthorityCaCertificateDescriptionsPublicKey) UnmarshalJSON(data []byte) error

type CertificateAuthorityCaCertificateDescriptionsPublicKeyFormatEnum 

type CertificateAuthorityCaCertificateDescriptionsPublicKeyFormatEnum string

The enum CertificateAuthorityCaCertificateDescriptionsPublicKeyFormatEnum.

func CertificateAuthorityCaCertificateDescriptionsPublicKeyFormatEnumRef 

func CertificateAuthorityCaCertificateDescriptionsPublicKeyFormatEnumRef(s string) *CertificateAuthorityCaCertificateDescriptionsPublicKeyFormatEnum

CertificateAuthorityCaCertificateDescriptionsPublicKeyFormatEnumRef returns a *CertificateAuthorityCaCertificateDescriptionsPublicKeyFormatEnum with the value of string s If the empty string is provided, nil is returned.

func (CertificateAuthorityCaCertificateDescriptionsPublicKeyFormatEnum) Validate 

func (v CertificateAuthorityCaCertificateDescriptionsPublicKeyFormatEnum) Validate() error

type CertificateAuthorityCaCertificateDescriptionsSubjectDescription 

type CertificateAuthorityCaCertificateDescriptionsSubjectDescription struct {
	Subject         *CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubject        `json:"subject"`
	SubjectAltName  *CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltName `json:"subjectAltName"`
	HexSerialNumber *string                                                                        `json:"hexSerialNumber"`
	Lifetime        *string                                                                        `json:"lifetime"`
	NotBeforeTime   *string                                                                        `json:"notBeforeTime"`
	NotAfterTime    *string                                                                        `json:"notAfterTime"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityCaCertificateDescriptionsSubjectDescription *CertificateAuthorityCaCertificateDescriptionsSubjectDescription = &CertificateAuthorityCaCertificateDescriptionsSubjectDescription{empty: true}

This object is used to assert a desired state where this CertificateAuthorityCaCertificateDescriptionsSubjectDescription is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityCaCertificateDescriptionsSubjectDescription) Empty 

func (r *CertificateAuthorityCaCertificateDescriptionsSubjectDescription) Empty() bool

func (*CertificateAuthorityCaCertificateDescriptionsSubjectDescription) HashCode 

func (r *CertificateAuthorityCaCertificateDescriptionsSubjectDescription) HashCode() string

func (*CertificateAuthorityCaCertificateDescriptionsSubjectDescription) String 

func (r *CertificateAuthorityCaCertificateDescriptionsSubjectDescription) String() string

func (*CertificateAuthorityCaCertificateDescriptionsSubjectDescription) UnmarshalJSON 

func (r *CertificateAuthorityCaCertificateDescriptionsSubjectDescription) UnmarshalJSON(data []byte) error

type CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubject 

type CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubject struct {
	CommonName         *string `json:"commonName"`
	CountryCode        *string `json:"countryCode"`
	Organization       *string `json:"organization"`
	OrganizationalUnit *string `json:"organizationalUnit"`
	Locality           *string `json:"locality"`
	Province           *string `json:"province"`
	StreetAddress      *string `json:"streetAddress"`
	PostalCode         *string `json:"postalCode"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubject *CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubject = &CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubject{empty: true}

This object is used to assert a desired state where this CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubject is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubject) Empty 

func (r *CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubject) Empty() bool

func (*CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubject) HashCode 

func (r *CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubject) HashCode() string

func (*CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubject) String 

func (r *CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubject) String() string

func (*CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubject) UnmarshalJSON 

func (r *CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubject) UnmarshalJSON(data []byte) error

type CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltName 

type CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltName struct {
	DnsNames       []string                                                                                  `json:"dnsNames"`
	Uris           []string                                                                                  `json:"uris"`
	EmailAddresses []string                                                                                  `json:"emailAddresses"`
	IPAddresses    []string                                                                                  `json:"ipAddresses"`
	CustomSans     []CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSans `json:"customSans"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltName *CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltName = &CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltName{empty: true}

This object is used to assert a desired state where this CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltName is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltName) Empty 

func (r *CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltName) Empty() bool

func (*CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltName) HashCode 

func (r *CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltName) HashCode() string

func (*CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltName) String 

func (r *CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltName) String() string

func (*CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltName) UnmarshalJSON 

func (r *CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltName) UnmarshalJSON(data []byte) error

type CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSans 

type CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSans struct {
	ObjectId *CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSansObjectId `json:"objectId"`
	Critical *bool                                                                                            `json:"critical"`
	Value    *string                                                                                          `json:"value"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSans *CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSans = &CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSans{empty: true}

This object is used to assert a desired state where this CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSans is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSans) Empty 

func (r *CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSans) Empty() bool

func (*CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSans) HashCode 

func (r *CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSans) HashCode() string

func (*CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSans) String 

func (r *CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSans) String() string

func (*CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSans) UnmarshalJSON 

func (r *CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSans) UnmarshalJSON(data []byte) error

type CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSansObjectId 

type CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSansObjectId struct {
	ObjectIdPath []int64 `json:"objectIdPath"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSansObjectId *CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSansObjectId = &CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSansObjectId{empty: true}

This object is used to assert a desired state where this CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSansObjectId is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSansObjectId) Empty 

func (r *CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSansObjectId) Empty() bool

func (*CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSansObjectId) HashCode 

func (r *CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSansObjectId) HashCode() string

func (*CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSansObjectId) String 

func (r *CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSansObjectId) String() string

func (*CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSansObjectId) UnmarshalJSON 

func (r *CertificateAuthorityCaCertificateDescriptionsSubjectDescriptionSubjectAltNameCustomSansObjectId) UnmarshalJSON(data []byte) error

type CertificateAuthorityCaCertificateDescriptionsSubjectKeyId 

type CertificateAuthorityCaCertificateDescriptionsSubjectKeyId struct {
	KeyId *string `json:"keyId"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityCaCertificateDescriptionsSubjectKeyId *CertificateAuthorityCaCertificateDescriptionsSubjectKeyId = &CertificateAuthorityCaCertificateDescriptionsSubjectKeyId{empty: true}

This object is used to assert a desired state where this CertificateAuthorityCaCertificateDescriptionsSubjectKeyId is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityCaCertificateDescriptionsSubjectKeyId) Empty 

func (r *CertificateAuthorityCaCertificateDescriptionsSubjectKeyId) Empty() bool

func (*CertificateAuthorityCaCertificateDescriptionsSubjectKeyId) HashCode 

func (r *CertificateAuthorityCaCertificateDescriptionsSubjectKeyId) HashCode() string

func (*CertificateAuthorityCaCertificateDescriptionsSubjectKeyId) String 

func (r *CertificateAuthorityCaCertificateDescriptionsSubjectKeyId) String() string

func (*CertificateAuthorityCaCertificateDescriptionsSubjectKeyId) UnmarshalJSON 

func (r *CertificateAuthorityCaCertificateDescriptionsSubjectKeyId) UnmarshalJSON(data []byte) error

type CertificateAuthorityCaCertificateDescriptionsX509Description 

type CertificateAuthorityCaCertificateDescriptionsX509Description struct {
	KeyUsage             *CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsage              `json:"keyUsage"`
	CaOptions            *CertificateAuthorityCaCertificateDescriptionsX509DescriptionCaOptions             `json:"caOptions"`
	PolicyIds            []CertificateAuthorityCaCertificateDescriptionsX509DescriptionPolicyIds            `json:"policyIds"`
	AiaOcspServers       []string                                                                           `json:"aiaOcspServers"`
	AdditionalExtensions []CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensions `json:"additionalExtensions"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityCaCertificateDescriptionsX509Description *CertificateAuthorityCaCertificateDescriptionsX509Description = &CertificateAuthorityCaCertificateDescriptionsX509Description{empty: true}

This object is used to assert a desired state where this CertificateAuthorityCaCertificateDescriptionsX509Description is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityCaCertificateDescriptionsX509Description) Empty 

func (r *CertificateAuthorityCaCertificateDescriptionsX509Description) Empty() bool

func (*CertificateAuthorityCaCertificateDescriptionsX509Description) HashCode 

func (r *CertificateAuthorityCaCertificateDescriptionsX509Description) HashCode() string

func (*CertificateAuthorityCaCertificateDescriptionsX509Description) String 

func (r *CertificateAuthorityCaCertificateDescriptionsX509Description) String() string

func (*CertificateAuthorityCaCertificateDescriptionsX509Description) UnmarshalJSON 

func (r *CertificateAuthorityCaCertificateDescriptionsX509Description) UnmarshalJSON(data []byte) error

type CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensions 

type CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensions struct {
	ObjectId *CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensionsObjectId `json:"objectId"`
	Critical *bool                                                                                     `json:"critical"`
	Value    *string                                                                                   `json:"value"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensions *CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensions = &CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensions{empty: true}

This object is used to assert a desired state where this CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensions is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensions) Empty 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensions) Empty() bool

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensions) HashCode 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensions) HashCode() string

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensions) String 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensions) String() string

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensions) UnmarshalJSON 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensions) UnmarshalJSON(data []byte) error

type CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensionsObjectId 

type CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensionsObjectId struct {
	ObjectIdPath []int64 `json:"objectIdPath"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensionsObjectId *CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensionsObjectId = &CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensionsObjectId{empty: true}

This object is used to assert a desired state where this CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensionsObjectId is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensionsObjectId) Empty 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensionsObjectId) Empty() bool

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensionsObjectId) HashCode 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensionsObjectId) HashCode() string

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensionsObjectId) String 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensionsObjectId) String() string

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensionsObjectId) UnmarshalJSON 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionAdditionalExtensionsObjectId) UnmarshalJSON(data []byte) error

type CertificateAuthorityCaCertificateDescriptionsX509DescriptionCaOptions 

type CertificateAuthorityCaCertificateDescriptionsX509DescriptionCaOptions struct {
	IsCa                *bool  `json:"isCa"`
	MaxIssuerPathLength *int64 `json:"maxIssuerPathLength"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityCaCertificateDescriptionsX509DescriptionCaOptions *CertificateAuthorityCaCertificateDescriptionsX509DescriptionCaOptions = &CertificateAuthorityCaCertificateDescriptionsX509DescriptionCaOptions{empty: true}

This object is used to assert a desired state where this CertificateAuthorityCaCertificateDescriptionsX509DescriptionCaOptions is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionCaOptions) Empty 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionCaOptions) Empty() bool

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionCaOptions) HashCode 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionCaOptions) HashCode() string

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionCaOptions) String 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionCaOptions) String() string

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionCaOptions) UnmarshalJSON 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionCaOptions) UnmarshalJSON(data []byte) error

type CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsage 

type CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsage struct {
	BaseKeyUsage             *CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageBaseKeyUsage              `json:"baseKeyUsage"`
	ExtendedKeyUsage         *CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageExtendedKeyUsage          `json:"extendedKeyUsage"`
	UnknownExtendedKeyUsages []CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageUnknownExtendedKeyUsages `json:"unknownExtendedKeyUsages"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsage *CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsage = &CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsage{empty: true}

This object is used to assert a desired state where this CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsage is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsage) Empty 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsage) Empty() bool

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsage) HashCode 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsage) HashCode() string

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsage) String 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsage) String() string

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsage) UnmarshalJSON 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsage) UnmarshalJSON(data []byte) error

type CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageBaseKeyUsage 

type CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageBaseKeyUsage struct {
	DigitalSignature  *bool `json:"digitalSignature"`
	ContentCommitment *bool `json:"contentCommitment"`
	KeyEncipherment   *bool `json:"keyEncipherment"`
	DataEncipherment  *bool `json:"dataEncipherment"`
	KeyAgreement      *bool `json:"keyAgreement"`
	CertSign          *bool `json:"certSign"`
	CrlSign           *bool `json:"crlSign"`
	EncipherOnly      *bool `json:"encipherOnly"`
	DecipherOnly      *bool `json:"decipherOnly"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageBaseKeyUsage *CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageBaseKeyUsage = &CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageBaseKeyUsage{empty: true}

This object is used to assert a desired state where this CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageBaseKeyUsage is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageBaseKeyUsage) Empty 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageBaseKeyUsage) Empty() bool

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageBaseKeyUsage) HashCode 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageBaseKeyUsage) HashCode() string

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageBaseKeyUsage) String 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageBaseKeyUsage) String() string

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageBaseKeyUsage) UnmarshalJSON 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageBaseKeyUsage) UnmarshalJSON(data []byte) error

type CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageExtendedKeyUsage 

type CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageExtendedKeyUsage struct {
	ServerAuth      *bool `json:"serverAuth"`
	ClientAuth      *bool `json:"clientAuth"`
	CodeSigning     *bool `json:"codeSigning"`
	EmailProtection *bool `json:"emailProtection"`
	TimeStamping    *bool `json:"timeStamping"`
	OcspSigning     *bool `json:"ocspSigning"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageExtendedKeyUsage *CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageExtendedKeyUsage = &CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageExtendedKeyUsage{empty: true}

This object is used to assert a desired state where this CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageExtendedKeyUsage is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageExtendedKeyUsage) Empty 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageExtendedKeyUsage) Empty() bool

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageExtendedKeyUsage) HashCode 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageExtendedKeyUsage) HashCode() string

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageExtendedKeyUsage) String 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageExtendedKeyUsage) String() string

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageExtendedKeyUsage) UnmarshalJSON 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageExtendedKeyUsage) UnmarshalJSON(data []byte) error

type CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageUnknownExtendedKeyUsages 

type CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageUnknownExtendedKeyUsages struct {
	ObjectIdPath []int64 `json:"objectIdPath"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageUnknownExtendedKeyUsages *CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageUnknownExtendedKeyUsages = &CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageUnknownExtendedKeyUsages{empty: true}

This object is used to assert a desired state where this CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageUnknownExtendedKeyUsages is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageUnknownExtendedKeyUsages) Empty 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageUnknownExtendedKeyUsages) Empty() bool

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageUnknownExtendedKeyUsages) HashCode 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageUnknownExtendedKeyUsages) HashCode() string

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageUnknownExtendedKeyUsages) String 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageUnknownExtendedKeyUsages) String() string

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageUnknownExtendedKeyUsages) UnmarshalJSON 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionKeyUsageUnknownExtendedKeyUsages) UnmarshalJSON(data []byte) error

type CertificateAuthorityCaCertificateDescriptionsX509DescriptionPolicyIds 

type CertificateAuthorityCaCertificateDescriptionsX509DescriptionPolicyIds struct {
	ObjectIdPath []int64 `json:"objectIdPath"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityCaCertificateDescriptionsX509DescriptionPolicyIds *CertificateAuthorityCaCertificateDescriptionsX509DescriptionPolicyIds = &CertificateAuthorityCaCertificateDescriptionsX509DescriptionPolicyIds{empty: true}

This object is used to assert a desired state where this CertificateAuthorityCaCertificateDescriptionsX509DescriptionPolicyIds is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionPolicyIds) Empty 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionPolicyIds) Empty() bool

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionPolicyIds) HashCode 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionPolicyIds) HashCode() string

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionPolicyIds) String 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionPolicyIds) String() string

func (*CertificateAuthorityCaCertificateDescriptionsX509DescriptionPolicyIds) UnmarshalJSON 

func (r *CertificateAuthorityCaCertificateDescriptionsX509DescriptionPolicyIds) UnmarshalJSON(data []byte) error

type CertificateAuthorityConfig 

type CertificateAuthorityConfig struct {
	SubjectConfig *CertificateAuthorityConfigSubjectConfig `json:"subjectConfig"`
	X509Config    *CertificateAuthorityConfigX509Config    `json:"x509Config"`
	PublicKey     *CertificateAuthorityConfigPublicKey     `json:"publicKey"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityConfig *CertificateAuthorityConfig = &CertificateAuthorityConfig{empty: true}

This object is used to assert a desired state where this CertificateAuthorityConfig is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityConfig) Empty 

func (r *CertificateAuthorityConfig) Empty() bool

func (*CertificateAuthorityConfig) HashCode 

func (r *CertificateAuthorityConfig) HashCode() string

func (*CertificateAuthorityConfig) String 

func (r *CertificateAuthorityConfig) String() string

func (*CertificateAuthorityConfig) UnmarshalJSON 

func (r *CertificateAuthorityConfig) UnmarshalJSON(data []byte) error

type CertificateAuthorityConfigPublicKey 

type CertificateAuthorityConfigPublicKey struct {
	Key    *string                                        `json:"key"`
	Format *CertificateAuthorityConfigPublicKeyFormatEnum `json:"format"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityConfigPublicKey *CertificateAuthorityConfigPublicKey = &CertificateAuthorityConfigPublicKey{empty: true}

This object is used to assert a desired state where this CertificateAuthorityConfigPublicKey is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityConfigPublicKey) Empty 

func (r *CertificateAuthorityConfigPublicKey) Empty() bool

func (*CertificateAuthorityConfigPublicKey) HashCode 

func (r *CertificateAuthorityConfigPublicKey) HashCode() string

func (*CertificateAuthorityConfigPublicKey) String 

func (r *CertificateAuthorityConfigPublicKey) String() string

func (*CertificateAuthorityConfigPublicKey) UnmarshalJSON 

func (r *CertificateAuthorityConfigPublicKey) UnmarshalJSON(data []byte) error

type CertificateAuthorityConfigPublicKeyFormatEnum 

type CertificateAuthorityConfigPublicKeyFormatEnum string

The enum CertificateAuthorityConfigPublicKeyFormatEnum.

func CertificateAuthorityConfigPublicKeyFormatEnumRef 

func CertificateAuthorityConfigPublicKeyFormatEnumRef(s string) *CertificateAuthorityConfigPublicKeyFormatEnum

CertificateAuthorityConfigPublicKeyFormatEnumRef returns a *CertificateAuthorityConfigPublicKeyFormatEnum with the value of string s If the empty string is provided, nil is returned.

func (CertificateAuthorityConfigPublicKeyFormatEnum) Validate 

func (v CertificateAuthorityConfigPublicKeyFormatEnum) Validate() error

type CertificateAuthorityConfigSubjectConfig 

type CertificateAuthorityConfigSubjectConfig struct {
	Subject        *CertificateAuthorityConfigSubjectConfigSubject        `json:"subject"`
	SubjectAltName *CertificateAuthorityConfigSubjectConfigSubjectAltName `json:"subjectAltName"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityConfigSubjectConfig *CertificateAuthorityConfigSubjectConfig = &CertificateAuthorityConfigSubjectConfig{empty: true}

This object is used to assert a desired state where this CertificateAuthorityConfigSubjectConfig is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityConfigSubjectConfig) Empty 

func (r *CertificateAuthorityConfigSubjectConfig) Empty() bool

func (*CertificateAuthorityConfigSubjectConfig) HashCode 

func (r *CertificateAuthorityConfigSubjectConfig) HashCode() string

func (*CertificateAuthorityConfigSubjectConfig) String 

func (r *CertificateAuthorityConfigSubjectConfig) String() string

func (*CertificateAuthorityConfigSubjectConfig) UnmarshalJSON 

func (r *CertificateAuthorityConfigSubjectConfig) UnmarshalJSON(data []byte) error

type CertificateAuthorityConfigSubjectConfigSubject 

type CertificateAuthorityConfigSubjectConfigSubject struct {
	CommonName         *string `json:"commonName"`
	CountryCode        *string `json:"countryCode"`
	Organization       *string `json:"organization"`
	OrganizationalUnit *string `json:"organizationalUnit"`
	Locality           *string `json:"locality"`
	Province           *string `json:"province"`
	StreetAddress      *string `json:"streetAddress"`
	PostalCode         *string `json:"postalCode"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityConfigSubjectConfigSubject *CertificateAuthorityConfigSubjectConfigSubject = &CertificateAuthorityConfigSubjectConfigSubject{empty: true}

This object is used to assert a desired state where this CertificateAuthorityConfigSubjectConfigSubject is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityConfigSubjectConfigSubject) Empty 

func (r *CertificateAuthorityConfigSubjectConfigSubject) Empty() bool

func (*CertificateAuthorityConfigSubjectConfigSubject) HashCode 

func (r *CertificateAuthorityConfigSubjectConfigSubject) HashCode() string

func (*CertificateAuthorityConfigSubjectConfigSubject) String 

func (r *CertificateAuthorityConfigSubjectConfigSubject) String() string

func (*CertificateAuthorityConfigSubjectConfigSubject) UnmarshalJSON 

func (r *CertificateAuthorityConfigSubjectConfigSubject) UnmarshalJSON(data []byte) error

type CertificateAuthorityConfigSubjectConfigSubjectAltName 

type CertificateAuthorityConfigSubjectConfigSubjectAltName struct {
	DnsNames       []string                                                          `json:"dnsNames"`
	Uris           []string                                                          `json:"uris"`
	EmailAddresses []string                                                          `json:"emailAddresses"`
	IPAddresses    []string                                                          `json:"ipAddresses"`
	CustomSans     []CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSans `json:"customSans"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityConfigSubjectConfigSubjectAltName *CertificateAuthorityConfigSubjectConfigSubjectAltName = &CertificateAuthorityConfigSubjectConfigSubjectAltName{empty: true}

This object is used to assert a desired state where this CertificateAuthorityConfigSubjectConfigSubjectAltName is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityConfigSubjectConfigSubjectAltName) Empty 

func (r *CertificateAuthorityConfigSubjectConfigSubjectAltName) Empty() bool

func (*CertificateAuthorityConfigSubjectConfigSubjectAltName) HashCode 

func (r *CertificateAuthorityConfigSubjectConfigSubjectAltName) HashCode() string

func (*CertificateAuthorityConfigSubjectConfigSubjectAltName) String 

func (r *CertificateAuthorityConfigSubjectConfigSubjectAltName) String() string

func (*CertificateAuthorityConfigSubjectConfigSubjectAltName) UnmarshalJSON 

func (r *CertificateAuthorityConfigSubjectConfigSubjectAltName) UnmarshalJSON(data []byte) error

type CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSans 

type CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSans struct {
	ObjectId *CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSansObjectId `json:"objectId"`
	Critical *bool                                                                    `json:"critical"`
	Value    *string                                                                  `json:"value"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSans *CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSans = &CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSans{empty: true}

This object is used to assert a desired state where this CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSans is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSans) Empty 

func (r *CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSans) Empty() bool

func (*CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSans) HashCode 

func (r *CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSans) HashCode() string

func (*CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSans) String 

func (r *CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSans) String() string

func (*CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSans) UnmarshalJSON 

func (r *CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSans) UnmarshalJSON(data []byte) error

type CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSansObjectId 

type CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSansObjectId struct {
	ObjectIdPath []int64 `json:"objectIdPath"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSansObjectId *CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSansObjectId = &CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSansObjectId{empty: true}

This object is used to assert a desired state where this CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSansObjectId is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSansObjectId) Empty 

func (r *CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSansObjectId) Empty() bool

func (*CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSansObjectId) HashCode 

func (r *CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSansObjectId) HashCode() string

func (*CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSansObjectId) String 

func (r *CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSansObjectId) String() string

func (*CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSansObjectId) UnmarshalJSON 

func (r *CertificateAuthorityConfigSubjectConfigSubjectAltNameCustomSansObjectId) UnmarshalJSON(data []byte) error

type CertificateAuthorityConfigX509Config 

type CertificateAuthorityConfigX509Config struct {
	KeyUsage             *CertificateAuthorityConfigX509ConfigKeyUsage              `json:"keyUsage"`
	CaOptions            *CertificateAuthorityConfigX509ConfigCaOptions             `json:"caOptions"`
	PolicyIds            []CertificateAuthorityConfigX509ConfigPolicyIds            `json:"policyIds"`
	AiaOcspServers       []string                                                   `json:"aiaOcspServers"`
	AdditionalExtensions []CertificateAuthorityConfigX509ConfigAdditionalExtensions `json:"additionalExtensions"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityConfigX509Config *CertificateAuthorityConfigX509Config = &CertificateAuthorityConfigX509Config{empty: true}

This object is used to assert a desired state where this CertificateAuthorityConfigX509Config is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityConfigX509Config) Empty 

func (r *CertificateAuthorityConfigX509Config) Empty() bool

func (*CertificateAuthorityConfigX509Config) HashCode 

func (r *CertificateAuthorityConfigX509Config) HashCode() string

func (*CertificateAuthorityConfigX509Config) String 

func (r *CertificateAuthorityConfigX509Config) String() string

func (*CertificateAuthorityConfigX509Config) UnmarshalJSON 

func (r *CertificateAuthorityConfigX509Config) UnmarshalJSON(data []byte) error

type CertificateAuthorityConfigX509ConfigAdditionalExtensions 

type CertificateAuthorityConfigX509ConfigAdditionalExtensions struct {
	ObjectId *CertificateAuthorityConfigX509ConfigAdditionalExtensionsObjectId `json:"objectId"`
	Critical *bool                                                             `json:"critical"`
	Value    *string                                                           `json:"value"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityConfigX509ConfigAdditionalExtensions *CertificateAuthorityConfigX509ConfigAdditionalExtensions = &CertificateAuthorityConfigX509ConfigAdditionalExtensions{empty: true}

This object is used to assert a desired state where this CertificateAuthorityConfigX509ConfigAdditionalExtensions is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityConfigX509ConfigAdditionalExtensions) Empty 

func (r *CertificateAuthorityConfigX509ConfigAdditionalExtensions) Empty() bool

func (*CertificateAuthorityConfigX509ConfigAdditionalExtensions) HashCode 

func (r *CertificateAuthorityConfigX509ConfigAdditionalExtensions) HashCode() string

func (*CertificateAuthorityConfigX509ConfigAdditionalExtensions) String 

func (r *CertificateAuthorityConfigX509ConfigAdditionalExtensions) String() string

func (*CertificateAuthorityConfigX509ConfigAdditionalExtensions) UnmarshalJSON 

func (r *CertificateAuthorityConfigX509ConfigAdditionalExtensions) UnmarshalJSON(data []byte) error

type CertificateAuthorityConfigX509ConfigAdditionalExtensionsObjectId 

type CertificateAuthorityConfigX509ConfigAdditionalExtensionsObjectId struct {
	ObjectIdPath []int64 `json:"objectIdPath"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityConfigX509ConfigAdditionalExtensionsObjectId *CertificateAuthorityConfigX509ConfigAdditionalExtensionsObjectId = &CertificateAuthorityConfigX509ConfigAdditionalExtensionsObjectId{empty: true}

This object is used to assert a desired state where this CertificateAuthorityConfigX509ConfigAdditionalExtensionsObjectId is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityConfigX509ConfigAdditionalExtensionsObjectId) Empty 

func (r *CertificateAuthorityConfigX509ConfigAdditionalExtensionsObjectId) Empty() bool

func (*CertificateAuthorityConfigX509ConfigAdditionalExtensionsObjectId) HashCode 

func (r *CertificateAuthorityConfigX509ConfigAdditionalExtensionsObjectId) HashCode() string

func (*CertificateAuthorityConfigX509ConfigAdditionalExtensionsObjectId) String 

func (r *CertificateAuthorityConfigX509ConfigAdditionalExtensionsObjectId) String() string

func (*CertificateAuthorityConfigX509ConfigAdditionalExtensionsObjectId) UnmarshalJSON 

func (r *CertificateAuthorityConfigX509ConfigAdditionalExtensionsObjectId) UnmarshalJSON(data []byte) error

type CertificateAuthorityConfigX509ConfigCaOptions 

type CertificateAuthorityConfigX509ConfigCaOptions struct {
	IsCa                    *bool  `json:"isCa"`
	MaxIssuerPathLength     *int64 `json:"maxIssuerPathLength"`
	ZeroMaxIssuerPathLength *bool  `json:"zeroMaxIssuerPathLength"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityConfigX509ConfigCaOptions *CertificateAuthorityConfigX509ConfigCaOptions = &CertificateAuthorityConfigX509ConfigCaOptions{empty: true}

This object is used to assert a desired state where this CertificateAuthorityConfigX509ConfigCaOptions is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityConfigX509ConfigCaOptions) Empty 

func (r *CertificateAuthorityConfigX509ConfigCaOptions) Empty() bool

func (*CertificateAuthorityConfigX509ConfigCaOptions) HashCode 

func (r *CertificateAuthorityConfigX509ConfigCaOptions) HashCode() string

func (*CertificateAuthorityConfigX509ConfigCaOptions) String 

func (r *CertificateAuthorityConfigX509ConfigCaOptions) String() string

func (*CertificateAuthorityConfigX509ConfigCaOptions) UnmarshalJSON 

func (r *CertificateAuthorityConfigX509ConfigCaOptions) UnmarshalJSON(data []byte) error

type CertificateAuthorityConfigX509ConfigKeyUsage 

type CertificateAuthorityConfigX509ConfigKeyUsage struct {
	BaseKeyUsage             *CertificateAuthorityConfigX509ConfigKeyUsageBaseKeyUsage              `json:"baseKeyUsage"`
	ExtendedKeyUsage         *CertificateAuthorityConfigX509ConfigKeyUsageExtendedKeyUsage          `json:"extendedKeyUsage"`
	UnknownExtendedKeyUsages []CertificateAuthorityConfigX509ConfigKeyUsageUnknownExtendedKeyUsages `json:"unknownExtendedKeyUsages"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityConfigX509ConfigKeyUsage *CertificateAuthorityConfigX509ConfigKeyUsage = &CertificateAuthorityConfigX509ConfigKeyUsage{empty: true}

This object is used to assert a desired state where this CertificateAuthorityConfigX509ConfigKeyUsage is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityConfigX509ConfigKeyUsage) Empty 

func (r *CertificateAuthorityConfigX509ConfigKeyUsage) Empty() bool

func (*CertificateAuthorityConfigX509ConfigKeyUsage) HashCode 

func (r *CertificateAuthorityConfigX509ConfigKeyUsage) HashCode() string

func (*CertificateAuthorityConfigX509ConfigKeyUsage) String 

func (r *CertificateAuthorityConfigX509ConfigKeyUsage) String() string

func (*CertificateAuthorityConfigX509ConfigKeyUsage) UnmarshalJSON 

func (r *CertificateAuthorityConfigX509ConfigKeyUsage) UnmarshalJSON(data []byte) error

type CertificateAuthorityConfigX509ConfigKeyUsageBaseKeyUsage 

type CertificateAuthorityConfigX509ConfigKeyUsageBaseKeyUsage struct {
	DigitalSignature  *bool `json:"digitalSignature"`
	ContentCommitment *bool `json:"contentCommitment"`
	KeyEncipherment   *bool `json:"keyEncipherment"`
	DataEncipherment  *bool `json:"dataEncipherment"`
	KeyAgreement      *bool `json:"keyAgreement"`
	CertSign          *bool `json:"certSign"`
	CrlSign           *bool `json:"crlSign"`
	EncipherOnly      *bool `json:"encipherOnly"`
	DecipherOnly      *bool `json:"decipherOnly"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityConfigX509ConfigKeyUsageBaseKeyUsage *CertificateAuthorityConfigX509ConfigKeyUsageBaseKeyUsage = &CertificateAuthorityConfigX509ConfigKeyUsageBaseKeyUsage{empty: true}

This object is used to assert a desired state where this CertificateAuthorityConfigX509ConfigKeyUsageBaseKeyUsage is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityConfigX509ConfigKeyUsageBaseKeyUsage) Empty 

func (r *CertificateAuthorityConfigX509ConfigKeyUsageBaseKeyUsage) Empty() bool

func (*CertificateAuthorityConfigX509ConfigKeyUsageBaseKeyUsage) HashCode 

func (r *CertificateAuthorityConfigX509ConfigKeyUsageBaseKeyUsage) HashCode() string

func (*CertificateAuthorityConfigX509ConfigKeyUsageBaseKeyUsage) String 

func (r *CertificateAuthorityConfigX509ConfigKeyUsageBaseKeyUsage) String() string

func (*CertificateAuthorityConfigX509ConfigKeyUsageBaseKeyUsage) UnmarshalJSON 

func (r *CertificateAuthorityConfigX509ConfigKeyUsageBaseKeyUsage) UnmarshalJSON(data []byte) error

type CertificateAuthorityConfigX509ConfigKeyUsageExtendedKeyUsage 

type CertificateAuthorityConfigX509ConfigKeyUsageExtendedKeyUsage struct {
	ServerAuth      *bool `json:"serverAuth"`
	ClientAuth      *bool `json:"clientAuth"`
	CodeSigning     *bool `json:"codeSigning"`
	EmailProtection *bool `json:"emailProtection"`
	TimeStamping    *bool `json:"timeStamping"`
	OcspSigning     *bool `json:"ocspSigning"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityConfigX509ConfigKeyUsageExtendedKeyUsage *CertificateAuthorityConfigX509ConfigKeyUsageExtendedKeyUsage = &CertificateAuthorityConfigX509ConfigKeyUsageExtendedKeyUsage{empty: true}

This object is used to assert a desired state where this CertificateAuthorityConfigX509ConfigKeyUsageExtendedKeyUsage is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityConfigX509ConfigKeyUsageExtendedKeyUsage) Empty 

func (r *CertificateAuthorityConfigX509ConfigKeyUsageExtendedKeyUsage) Empty() bool

func (*CertificateAuthorityConfigX509ConfigKeyUsageExtendedKeyUsage) HashCode 

func (r *CertificateAuthorityConfigX509ConfigKeyUsageExtendedKeyUsage) HashCode() string

func (*CertificateAuthorityConfigX509ConfigKeyUsageExtendedKeyUsage) String 

func (r *CertificateAuthorityConfigX509ConfigKeyUsageExtendedKeyUsage) String() string

func (*CertificateAuthorityConfigX509ConfigKeyUsageExtendedKeyUsage) UnmarshalJSON 

func (r *CertificateAuthorityConfigX509ConfigKeyUsageExtendedKeyUsage) UnmarshalJSON(data []byte) error

type CertificateAuthorityConfigX509ConfigKeyUsageUnknownExtendedKeyUsages 

type CertificateAuthorityConfigX509ConfigKeyUsageUnknownExtendedKeyUsages struct {
	ObjectIdPath []int64 `json:"objectIdPath"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityConfigX509ConfigKeyUsageUnknownExtendedKeyUsages *CertificateAuthorityConfigX509ConfigKeyUsageUnknownExtendedKeyUsages = &CertificateAuthorityConfigX509ConfigKeyUsageUnknownExtendedKeyUsages{empty: true}

This object is used to assert a desired state where this CertificateAuthorityConfigX509ConfigKeyUsageUnknownExtendedKeyUsages is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityConfigX509ConfigKeyUsageUnknownExtendedKeyUsages) Empty 

func (r *CertificateAuthorityConfigX509ConfigKeyUsageUnknownExtendedKeyUsages) Empty() bool

func (*CertificateAuthorityConfigX509ConfigKeyUsageUnknownExtendedKeyUsages) HashCode 

func (r *CertificateAuthorityConfigX509ConfigKeyUsageUnknownExtendedKeyUsages) HashCode() string

func (*CertificateAuthorityConfigX509ConfigKeyUsageUnknownExtendedKeyUsages) String 

func (r *CertificateAuthorityConfigX509ConfigKeyUsageUnknownExtendedKeyUsages) String() string

func (*CertificateAuthorityConfigX509ConfigKeyUsageUnknownExtendedKeyUsages) UnmarshalJSON 

func (r *CertificateAuthorityConfigX509ConfigKeyUsageUnknownExtendedKeyUsages) UnmarshalJSON(data []byte) error

type CertificateAuthorityConfigX509ConfigPolicyIds 

type CertificateAuthorityConfigX509ConfigPolicyIds struct {
	ObjectIdPath []int64 `json:"objectIdPath"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityConfigX509ConfigPolicyIds *CertificateAuthorityConfigX509ConfigPolicyIds = &CertificateAuthorityConfigX509ConfigPolicyIds{empty: true}

This object is used to assert a desired state where this CertificateAuthorityConfigX509ConfigPolicyIds is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityConfigX509ConfigPolicyIds) Empty 

func (r *CertificateAuthorityConfigX509ConfigPolicyIds) Empty() bool

func (*CertificateAuthorityConfigX509ConfigPolicyIds) HashCode 

func (r *CertificateAuthorityConfigX509ConfigPolicyIds) HashCode() string

func (*CertificateAuthorityConfigX509ConfigPolicyIds) String 

func (r *CertificateAuthorityConfigX509ConfigPolicyIds) String() string

func (*CertificateAuthorityConfigX509ConfigPolicyIds) UnmarshalJSON 

func (r *CertificateAuthorityConfigX509ConfigPolicyIds) UnmarshalJSON(data []byte) error

type CertificateAuthorityKeySpec 

type CertificateAuthorityKeySpec struct {
	CloudKmsKeyVersion *string                                   `json:"cloudKmsKeyVersion"`
	Algorithm          *CertificateAuthorityKeySpecAlgorithmEnum `json:"algorithm"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthorityKeySpec *CertificateAuthorityKeySpec = &CertificateAuthorityKeySpec{empty: true}

This object is used to assert a desired state where this CertificateAuthorityKeySpec is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthorityKeySpec) Empty 

func (r *CertificateAuthorityKeySpec) Empty() bool

func (*CertificateAuthorityKeySpec) HashCode 

func (r *CertificateAuthorityKeySpec) HashCode() string

func (*CertificateAuthorityKeySpec) String 

func (r *CertificateAuthorityKeySpec) String() string

func (*CertificateAuthorityKeySpec) UnmarshalJSON 

func (r *CertificateAuthorityKeySpec) UnmarshalJSON(data []byte) error

type CertificateAuthorityKeySpecAlgorithmEnum 

type CertificateAuthorityKeySpecAlgorithmEnum string

The enum CertificateAuthorityKeySpecAlgorithmEnum.

func CertificateAuthorityKeySpecAlgorithmEnumRef 

func CertificateAuthorityKeySpecAlgorithmEnumRef(s string) *CertificateAuthorityKeySpecAlgorithmEnum

CertificateAuthorityKeySpecAlgorithmEnumRef returns a *CertificateAuthorityKeySpecAlgorithmEnum with the value of string s If the empty string is provided, nil is returned.

func (CertificateAuthorityKeySpecAlgorithmEnum) Validate 

func (v CertificateAuthorityKeySpecAlgorithmEnum) Validate() error

type CertificateAuthorityList 

type CertificateAuthorityList struct {
	Items []*CertificateAuthority
	// contains filtered or unexported fields
}

func (*CertificateAuthorityList) HasNext 

func (l *CertificateAuthorityList) HasNext() bool

func (*CertificateAuthorityList) Next 

func (l *CertificateAuthorityList) Next(ctx context.Context, c *Client) error

type CertificateAuthorityStateEnum 

type CertificateAuthorityStateEnum string

The enum CertificateAuthorityStateEnum.

func CertificateAuthorityStateEnumRef 

func CertificateAuthorityStateEnumRef(s string) *CertificateAuthorityStateEnum

CertificateAuthorityStateEnumRef returns a *CertificateAuthorityStateEnum with the value of string s If the empty string is provided, nil is returned.

func (CertificateAuthorityStateEnum) Validate 

func (v CertificateAuthorityStateEnum) Validate() error

type CertificateAuthoritySubordinateConfig 

type CertificateAuthoritySubordinateConfig struct {
	CertificateAuthority *string                                              `json:"certificateAuthority"`
	PemIssuerChain       *CertificateAuthoritySubordinateConfigPemIssuerChain `json:"pemIssuerChain"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthoritySubordinateConfig *CertificateAuthoritySubordinateConfig = &CertificateAuthoritySubordinateConfig{empty: true}

This object is used to assert a desired state where this CertificateAuthoritySubordinateConfig is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthoritySubordinateConfig) Empty 

func (r *CertificateAuthoritySubordinateConfig) Empty() bool

func (*CertificateAuthoritySubordinateConfig) HashCode 

func (r *CertificateAuthoritySubordinateConfig) HashCode() string

func (*CertificateAuthoritySubordinateConfig) String 

func (r *CertificateAuthoritySubordinateConfig) String() string

func (*CertificateAuthoritySubordinateConfig) UnmarshalJSON 

func (r *CertificateAuthoritySubordinateConfig) UnmarshalJSON(data []byte) error

type CertificateAuthoritySubordinateConfigPemIssuerChain 

type CertificateAuthoritySubordinateConfigPemIssuerChain struct {
	PemCertificates []string `json:"pemCertificates"`
	// contains filtered or unexported fields
}
var EmptyCertificateAuthoritySubordinateConfigPemIssuerChain *CertificateAuthoritySubordinateConfigPemIssuerChain = &CertificateAuthoritySubordinateConfigPemIssuerChain{empty: true}

This object is used to assert a desired state where this CertificateAuthoritySubordinateConfigPemIssuerChain is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateAuthoritySubordinateConfigPemIssuerChain) Empty 

func (r *CertificateAuthoritySubordinateConfigPemIssuerChain) Empty() bool

func (*CertificateAuthoritySubordinateConfigPemIssuerChain) HashCode 

func (r *CertificateAuthoritySubordinateConfigPemIssuerChain) HashCode() string

func (*CertificateAuthoritySubordinateConfigPemIssuerChain) String 

func (r *CertificateAuthoritySubordinateConfigPemIssuerChain) String() string

func (*CertificateAuthoritySubordinateConfigPemIssuerChain) UnmarshalJSON 

func (r *CertificateAuthoritySubordinateConfigPemIssuerChain) UnmarshalJSON(data []byte) error

type CertificateAuthorityTierEnum 

type CertificateAuthorityTierEnum string

The enum CertificateAuthorityTierEnum.

func CertificateAuthorityTierEnumRef 

func CertificateAuthorityTierEnumRef(s string) *CertificateAuthorityTierEnum

CertificateAuthorityTierEnumRef returns a *CertificateAuthorityTierEnum with the value of string s If the empty string is provided, nil is returned.

func (CertificateAuthorityTierEnum) Validate 

func (v CertificateAuthorityTierEnum) Validate() error

type CertificateAuthorityTypeEnum 

type CertificateAuthorityTypeEnum string

The enum CertificateAuthorityTypeEnum.

func CertificateAuthorityTypeEnumRef 

func CertificateAuthorityTypeEnumRef(s string) *CertificateAuthorityTypeEnum

CertificateAuthorityTypeEnumRef returns a *CertificateAuthorityTypeEnum with the value of string s If the empty string is provided, nil is returned.

func (CertificateAuthorityTypeEnum) Validate 

func (v CertificateAuthorityTypeEnum) Validate() error

type CertificateCertificateDescription 

type CertificateCertificateDescription struct {
	SubjectDescription        *CertificateCertificateDescriptionSubjectDescription `json:"subjectDescription"`
	X509Description           *CertificateCertificateDescriptionX509Description    `json:"x509Description"`
	PublicKey                 *CertificateCertificateDescriptionPublicKey          `json:"publicKey"`
	SubjectKeyId              *CertificateCertificateDescriptionSubjectKeyId       `json:"subjectKeyId"`
	AuthorityKeyId            *CertificateCertificateDescriptionAuthorityKeyId     `json:"authorityKeyId"`
	CrlDistributionPoints     []string                                             `json:"crlDistributionPoints"`
	AiaIssuingCertificateUrls []string                                             `json:"aiaIssuingCertificateUrls"`
	CertFingerprint           *CertificateCertificateDescriptionCertFingerprint    `json:"certFingerprint"`
	// contains filtered or unexported fields
}
var EmptyCertificateCertificateDescription *CertificateCertificateDescription = &CertificateCertificateDescription{empty: true}

This object is used to assert a desired state where this CertificateCertificateDescription is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateCertificateDescription) Empty 

func (r *CertificateCertificateDescription) Empty() bool

func (*CertificateCertificateDescription) HashCode 

func (r *CertificateCertificateDescription) HashCode() string

func (*CertificateCertificateDescription) String 

func (r *CertificateCertificateDescription) String() string

func (*CertificateCertificateDescription) UnmarshalJSON 

func (r *CertificateCertificateDescription) UnmarshalJSON(data []byte) error

type CertificateCertificateDescriptionAuthorityKeyId 

type CertificateCertificateDescriptionAuthorityKeyId struct {
	KeyId *string `json:"keyId"`
	// contains filtered or unexported fields
}
var EmptyCertificateCertificateDescriptionAuthorityKeyId *CertificateCertificateDescriptionAuthorityKeyId = &CertificateCertificateDescriptionAuthorityKeyId{empty: true}

This object is used to assert a desired state where this CertificateCertificateDescriptionAuthorityKeyId is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateCertificateDescriptionAuthorityKeyId) Empty 

func (r *CertificateCertificateDescriptionAuthorityKeyId) Empty() bool

func (*CertificateCertificateDescriptionAuthorityKeyId) HashCode 

func (r *CertificateCertificateDescriptionAuthorityKeyId) HashCode() string

func (*CertificateCertificateDescriptionAuthorityKeyId) String 

func (r *CertificateCertificateDescriptionAuthorityKeyId) String() string

func (*CertificateCertificateDescriptionAuthorityKeyId) UnmarshalJSON 

func (r *CertificateCertificateDescriptionAuthorityKeyId) UnmarshalJSON(data []byte) error

type CertificateCertificateDescriptionCertFingerprint 

type CertificateCertificateDescriptionCertFingerprint struct {
	Sha256Hash *string `json:"sha256Hash"`
	// contains filtered or unexported fields
}
var EmptyCertificateCertificateDescriptionCertFingerprint *CertificateCertificateDescriptionCertFingerprint = &CertificateCertificateDescriptionCertFingerprint{empty: true}

This object is used to assert a desired state where this CertificateCertificateDescriptionCertFingerprint is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateCertificateDescriptionCertFingerprint) Empty 

func (r *CertificateCertificateDescriptionCertFingerprint) Empty() bool

func (*CertificateCertificateDescriptionCertFingerprint) HashCode 

func (r *CertificateCertificateDescriptionCertFingerprint) HashCode() string

func (*CertificateCertificateDescriptionCertFingerprint) String 

func (r *CertificateCertificateDescriptionCertFingerprint) String() string

func (*CertificateCertificateDescriptionCertFingerprint) UnmarshalJSON 

func (r *CertificateCertificateDescriptionCertFingerprint) UnmarshalJSON(data []byte) error

type CertificateCertificateDescriptionPublicKey 

type CertificateCertificateDescriptionPublicKey struct {
	Key    *string                                               `json:"key"`
	Format *CertificateCertificateDescriptionPublicKeyFormatEnum `json:"format"`
	// contains filtered or unexported fields
}
var EmptyCertificateCertificateDescriptionPublicKey *CertificateCertificateDescriptionPublicKey = &CertificateCertificateDescriptionPublicKey{empty: true}

This object is used to assert a desired state where this CertificateCertificateDescriptionPublicKey is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateCertificateDescriptionPublicKey) Empty 

func (r *CertificateCertificateDescriptionPublicKey) Empty() bool

func (*CertificateCertificateDescriptionPublicKey) HashCode 

func (r *CertificateCertificateDescriptionPublicKey) HashCode() string

func (*CertificateCertificateDescriptionPublicKey) String 

func (r *CertificateCertificateDescriptionPublicKey) String() string

func (*CertificateCertificateDescriptionPublicKey) UnmarshalJSON 

func (r *CertificateCertificateDescriptionPublicKey) UnmarshalJSON(data []byte) error

type CertificateCertificateDescriptionPublicKeyFormatEnum 

type CertificateCertificateDescriptionPublicKeyFormatEnum string

The enum CertificateCertificateDescriptionPublicKeyFormatEnum.

func CertificateCertificateDescriptionPublicKeyFormatEnumRef 

func CertificateCertificateDescriptionPublicKeyFormatEnumRef(s string) *CertificateCertificateDescriptionPublicKeyFormatEnum

CertificateCertificateDescriptionPublicKeyFormatEnumRef returns a *CertificateCertificateDescriptionPublicKeyFormatEnum with the value of string s If the empty string is provided, nil is returned.

func (CertificateCertificateDescriptionPublicKeyFormatEnum) Validate 

func (v CertificateCertificateDescriptionPublicKeyFormatEnum) Validate() error

type CertificateCertificateDescriptionSubjectDescription 

type CertificateCertificateDescriptionSubjectDescription struct {
	Subject         *CertificateCertificateDescriptionSubjectDescriptionSubject        `json:"subject"`
	SubjectAltName  *CertificateCertificateDescriptionSubjectDescriptionSubjectAltName `json:"subjectAltName"`
	HexSerialNumber *string                                                            `json:"hexSerialNumber"`
	Lifetime        *string                                                            `json:"lifetime"`
	NotBeforeTime   *string                                                            `json:"notBeforeTime"`
	NotAfterTime    *string                                                            `json:"notAfterTime"`
	// contains filtered or unexported fields
}
var EmptyCertificateCertificateDescriptionSubjectDescription *CertificateCertificateDescriptionSubjectDescription = &CertificateCertificateDescriptionSubjectDescription{empty: true}

This object is used to assert a desired state where this CertificateCertificateDescriptionSubjectDescription is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateCertificateDescriptionSubjectDescription) Empty 

func (r *CertificateCertificateDescriptionSubjectDescription) Empty() bool

func (*CertificateCertificateDescriptionSubjectDescription) HashCode 

func (r *CertificateCertificateDescriptionSubjectDescription) HashCode() string

func (*CertificateCertificateDescriptionSubjectDescription) String 

func (r *CertificateCertificateDescriptionSubjectDescription) String() string

func (*CertificateCertificateDescriptionSubjectDescription) UnmarshalJSON 

func (r *CertificateCertificateDescriptionSubjectDescription) UnmarshalJSON(data []byte) error

type CertificateCertificateDescriptionSubjectDescriptionSubject 

type CertificateCertificateDescriptionSubjectDescriptionSubject struct {
	CommonName         *string `json:"commonName"`
	CountryCode        *string `json:"countryCode"`
	Organization       *string `json:"organization"`
	OrganizationalUnit *string `json:"organizationalUnit"`
	Locality           *string `json:"locality"`
	Province           *string `json:"province"`
	StreetAddress      *string `json:"streetAddress"`
	PostalCode         *string `json:"postalCode"`
	// contains filtered or unexported fields
}
var EmptyCertificateCertificateDescriptionSubjectDescriptionSubject *CertificateCertificateDescriptionSubjectDescriptionSubject = &CertificateCertificateDescriptionSubjectDescriptionSubject{empty: true}

This object is used to assert a desired state where this CertificateCertificateDescriptionSubjectDescriptionSubject is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateCertificateDescriptionSubjectDescriptionSubject) Empty 

func (r *CertificateCertificateDescriptionSubjectDescriptionSubject) Empty() bool

func (*CertificateCertificateDescriptionSubjectDescriptionSubject) HashCode 

func (r *CertificateCertificateDescriptionSubjectDescriptionSubject) HashCode() string

func (*CertificateCertificateDescriptionSubjectDescriptionSubject) String 

func (r *CertificateCertificateDescriptionSubjectDescriptionSubject) String() string

func (*CertificateCertificateDescriptionSubjectDescriptionSubject) UnmarshalJSON 

func (r *CertificateCertificateDescriptionSubjectDescriptionSubject) UnmarshalJSON(data []byte) error

type CertificateCertificateDescriptionSubjectDescriptionSubjectAltName 

type CertificateCertificateDescriptionSubjectDescriptionSubjectAltName struct {
	DnsNames       []string                                                                      `json:"dnsNames"`
	Uris           []string                                                                      `json:"uris"`
	EmailAddresses []string                                                                      `json:"emailAddresses"`
	IPAddresses    []string                                                                      `json:"ipAddresses"`
	CustomSans     []CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSans `json:"customSans"`
	// contains filtered or unexported fields
}
var EmptyCertificateCertificateDescriptionSubjectDescriptionSubjectAltName *CertificateCertificateDescriptionSubjectDescriptionSubjectAltName = &CertificateCertificateDescriptionSubjectDescriptionSubjectAltName{empty: true}

This object is used to assert a desired state where this CertificateCertificateDescriptionSubjectDescriptionSubjectAltName is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateCertificateDescriptionSubjectDescriptionSubjectAltName) Empty 

func (r *CertificateCertificateDescriptionSubjectDescriptionSubjectAltName) Empty() bool

func (*CertificateCertificateDescriptionSubjectDescriptionSubjectAltName) HashCode 

func (r *CertificateCertificateDescriptionSubjectDescriptionSubjectAltName) HashCode() string

func (*CertificateCertificateDescriptionSubjectDescriptionSubjectAltName) String 

func (r *CertificateCertificateDescriptionSubjectDescriptionSubjectAltName) String() string

func (*CertificateCertificateDescriptionSubjectDescriptionSubjectAltName) UnmarshalJSON 

func (r *CertificateCertificateDescriptionSubjectDescriptionSubjectAltName) UnmarshalJSON(data []byte) error

type CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSans 

type CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSans struct {
	ObjectId *CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSansObjectId `json:"objectId"`
	Critical *bool                                                                                `json:"critical"`
	Value    *string                                                                              `json:"value"`
	// contains filtered or unexported fields
}
var EmptyCertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSans *CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSans = &CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSans{empty: true}

This object is used to assert a desired state where this CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSans is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSans) Empty 

func (r *CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSans) Empty() bool

func (*CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSans) HashCode 

func (r *CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSans) HashCode() string

func (*CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSans) String 

func (r *CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSans) String() string

func (*CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSans) UnmarshalJSON 

func (r *CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSans) UnmarshalJSON(data []byte) error

type CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSansObjectId 

type CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSansObjectId struct {
	ObjectIdPath []int64 `json:"objectIdPath"`
	// contains filtered or unexported fields
}
var EmptyCertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSansObjectId *CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSansObjectId = &CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSansObjectId{empty: true}

This object is used to assert a desired state where this CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSansObjectId is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSansObjectId) Empty 

func (r *CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSansObjectId) Empty() bool

func (*CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSansObjectId) HashCode 

func (r *CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSansObjectId) HashCode() string

func (*CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSansObjectId) String 

func (r *CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSansObjectId) String() string

func (*CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSansObjectId) UnmarshalJSON 

func (r *CertificateCertificateDescriptionSubjectDescriptionSubjectAltNameCustomSansObjectId) UnmarshalJSON(data []byte) error

type CertificateCertificateDescriptionSubjectKeyId 

type CertificateCertificateDescriptionSubjectKeyId struct {
	KeyId *string `json:"keyId"`
	// contains filtered or unexported fields
}
var EmptyCertificateCertificateDescriptionSubjectKeyId *CertificateCertificateDescriptionSubjectKeyId = &CertificateCertificateDescriptionSubjectKeyId{empty: true}

This object is used to assert a desired state where this CertificateCertificateDescriptionSubjectKeyId is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateCertificateDescriptionSubjectKeyId) Empty 

func (r *CertificateCertificateDescriptionSubjectKeyId) Empty() bool

func (*CertificateCertificateDescriptionSubjectKeyId) HashCode 

func (r *CertificateCertificateDescriptionSubjectKeyId) HashCode() string

func (*CertificateCertificateDescriptionSubjectKeyId) String 

func (r *CertificateCertificateDescriptionSubjectKeyId) String() string

func (*CertificateCertificateDescriptionSubjectKeyId) UnmarshalJSON 

func (r *CertificateCertificateDescriptionSubjectKeyId) UnmarshalJSON(data []byte) error

type CertificateCertificateDescriptionX509Description 

type CertificateCertificateDescriptionX509Description struct {
	KeyUsage             *CertificateCertificateDescriptionX509DescriptionKeyUsage              `json:"keyUsage"`
	CaOptions            *CertificateCertificateDescriptionX509DescriptionCaOptions             `json:"caOptions"`
	PolicyIds            []CertificateCertificateDescriptionX509DescriptionPolicyIds            `json:"policyIds"`
	AiaOcspServers       []string                                                               `json:"aiaOcspServers"`
	AdditionalExtensions []CertificateCertificateDescriptionX509DescriptionAdditionalExtensions `json:"additionalExtensions"`
	// contains filtered or unexported fields
}
var EmptyCertificateCertificateDescriptionX509Description *CertificateCertificateDescriptionX509Description = &CertificateCertificateDescriptionX509Description{empty: true}

This object is used to assert a desired state where this CertificateCertificateDescriptionX509Description is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateCertificateDescriptionX509Description) Empty 

func (r *CertificateCertificateDescriptionX509Description) Empty() bool

func (*CertificateCertificateDescriptionX509Description) HashCode 

func (r *CertificateCertificateDescriptionX509Description) HashCode() string

func (*CertificateCertificateDescriptionX509Description) String 

func (r *CertificateCertificateDescriptionX509Description) String() string

func (*CertificateCertificateDescriptionX509Description) UnmarshalJSON 

func (r *CertificateCertificateDescriptionX509Description) UnmarshalJSON(data []byte) error

type CertificateCertificateDescriptionX509DescriptionAdditionalExtensions 

type CertificateCertificateDescriptionX509DescriptionAdditionalExtensions struct {
	ObjectId *CertificateCertificateDescriptionX509DescriptionAdditionalExtensionsObjectId `json:"objectId"`
	Critical *bool                                                                         `json:"critical"`
	Value    *string                                                                       `json:"value"`
	// contains filtered or unexported fields
}
var EmptyCertificateCertificateDescriptionX509DescriptionAdditionalExtensions *CertificateCertificateDescriptionX509DescriptionAdditionalExtensions = &CertificateCertificateDescriptionX509DescriptionAdditionalExtensions{empty: true}

This object is used to assert a desired state where this CertificateCertificateDescriptionX509DescriptionAdditionalExtensions is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateCertificateDescriptionX509DescriptionAdditionalExtensions) Empty 

func (r *CertificateCertificateDescriptionX509DescriptionAdditionalExtensions) Empty() bool

func (*CertificateCertificateDescriptionX509DescriptionAdditionalExtensions) HashCode 

func (r *CertificateCertificateDescriptionX509DescriptionAdditionalExtensions) HashCode() string

func (*CertificateCertificateDescriptionX509DescriptionAdditionalExtensions) String 

func (r *CertificateCertificateDescriptionX509DescriptionAdditionalExtensions) String() string

func (*CertificateCertificateDescriptionX509DescriptionAdditionalExtensions) UnmarshalJSON 

func (r *CertificateCertificateDescriptionX509DescriptionAdditionalExtensions) UnmarshalJSON(data []byte) error

type CertificateCertificateDescriptionX509DescriptionAdditionalExtensionsObjectId 

type CertificateCertificateDescriptionX509DescriptionAdditionalExtensionsObjectId struct {
	ObjectIdPath []int64 `json:"objectIdPath"`
	// contains filtered or unexported fields
}
var EmptyCertificateCertificateDescriptionX509DescriptionAdditionalExtensionsObjectId *CertificateCertificateDescriptionX509DescriptionAdditionalExtensionsObjectId = &CertificateCertificateDescriptionX509DescriptionAdditionalExtensionsObjectId{empty: true}

This object is used to assert a desired state where this CertificateCertificateDescriptionX509DescriptionAdditionalExtensionsObjectId is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateCertificateDescriptionX509DescriptionAdditionalExtensionsObjectId) Empty 

func (r *CertificateCertificateDescriptionX509DescriptionAdditionalExtensionsObjectId) Empty() bool

func (*CertificateCertificateDescriptionX509DescriptionAdditionalExtensionsObjectId) HashCode 

func (r *CertificateCertificateDescriptionX509DescriptionAdditionalExtensionsObjectId) HashCode() string

func (*CertificateCertificateDescriptionX509DescriptionAdditionalExtensionsObjectId) String 

func (r *CertificateCertificateDescriptionX509DescriptionAdditionalExtensionsObjectId) String() string

func (*CertificateCertificateDescriptionX509DescriptionAdditionalExtensionsObjectId) UnmarshalJSON 

func (r *CertificateCertificateDescriptionX509DescriptionAdditionalExtensionsObjectId) UnmarshalJSON(data []byte) error

type CertificateCertificateDescriptionX509DescriptionCaOptions 

type CertificateCertificateDescriptionX509DescriptionCaOptions struct {
	IsCa                *bool  `json:"isCa"`
	MaxIssuerPathLength *int64 `json:"maxIssuerPathLength"`
	// contains filtered or unexported fields
}
var EmptyCertificateCertificateDescriptionX509DescriptionCaOptions *CertificateCertificateDescriptionX509DescriptionCaOptions = &CertificateCertificateDescriptionX509DescriptionCaOptions{empty: true}

This object is used to assert a desired state where this CertificateCertificateDescriptionX509DescriptionCaOptions is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateCertificateDescriptionX509DescriptionCaOptions) Empty 

func (r *CertificateCertificateDescriptionX509DescriptionCaOptions) Empty() bool

func (*CertificateCertificateDescriptionX509DescriptionCaOptions) HashCode 

func (r *CertificateCertificateDescriptionX509DescriptionCaOptions) HashCode() string

func (*CertificateCertificateDescriptionX509DescriptionCaOptions) String 

func (r *CertificateCertificateDescriptionX509DescriptionCaOptions) String() string

func (*CertificateCertificateDescriptionX509DescriptionCaOptions) UnmarshalJSON 

func (r *CertificateCertificateDescriptionX509DescriptionCaOptions) UnmarshalJSON(data []byte) error

type CertificateCertificateDescriptionX509DescriptionKeyUsage 

type CertificateCertificateDescriptionX509DescriptionKeyUsage struct {
	BaseKeyUsage             *CertificateCertificateDescriptionX509DescriptionKeyUsageBaseKeyUsage              `json:"baseKeyUsage"`
	ExtendedKeyUsage         *CertificateCertificateDescriptionX509DescriptionKeyUsageExtendedKeyUsage          `json:"extendedKeyUsage"`
	UnknownExtendedKeyUsages []CertificateCertificateDescriptionX509DescriptionKeyUsageUnknownExtendedKeyUsages `json:"unknownExtendedKeyUsages"`
	// contains filtered or unexported fields
}
var EmptyCertificateCertificateDescriptionX509DescriptionKeyUsage *CertificateCertificateDescriptionX509DescriptionKeyUsage = &CertificateCertificateDescriptionX509DescriptionKeyUsage{empty: true}

This object is used to assert a desired state where this CertificateCertificateDescriptionX509DescriptionKeyUsage is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateCertificateDescriptionX509DescriptionKeyUsage) Empty 

func (r *CertificateCertificateDescriptionX509DescriptionKeyUsage) Empty() bool

func (*CertificateCertificateDescriptionX509DescriptionKeyUsage) HashCode 

func (r *CertificateCertificateDescriptionX509DescriptionKeyUsage) HashCode() string

func (*CertificateCertificateDescriptionX509DescriptionKeyUsage) String 

func (r *CertificateCertificateDescriptionX509DescriptionKeyUsage) String() string

func (*CertificateCertificateDescriptionX509DescriptionKeyUsage) UnmarshalJSON 

func (r *CertificateCertificateDescriptionX509DescriptionKeyUsage) UnmarshalJSON(data []byte) error

type CertificateCertificateDescriptionX509DescriptionKeyUsageBaseKeyUsage 

type CertificateCertificateDescriptionX509DescriptionKeyUsageBaseKeyUsage struct {
	DigitalSignature  *bool `json:"digitalSignature"`
	ContentCommitment *bool `json:"contentCommitment"`
	KeyEncipherment   *bool `json:"keyEncipherment"`
	DataEncipherment  *bool `json:"dataEncipherment"`
	KeyAgreement      *bool `json:"keyAgreement"`
	CertSign          *bool `json:"certSign"`
	CrlSign           *bool `json:"crlSign"`
	EncipherOnly      *bool `json:"encipherOnly"`
	DecipherOnly      *bool `json:"decipherOnly"`
	// contains filtered or unexported fields
}
var EmptyCertificateCertificateDescriptionX509DescriptionKeyUsageBaseKeyUsage *CertificateCertificateDescriptionX509DescriptionKeyUsageBaseKeyUsage = &CertificateCertificateDescriptionX509DescriptionKeyUsageBaseKeyUsage{empty: true}

This object is used to assert a desired state where this CertificateCertificateDescriptionX509DescriptionKeyUsageBaseKeyUsage is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateCertificateDescriptionX509DescriptionKeyUsageBaseKeyUsage) Empty 

func (r *CertificateCertificateDescriptionX509DescriptionKeyUsageBaseKeyUsage) Empty() bool

func (*CertificateCertificateDescriptionX509DescriptionKeyUsageBaseKeyUsage) HashCode 

func (r *CertificateCertificateDescriptionX509DescriptionKeyUsageBaseKeyUsage) HashCode() string

func (*CertificateCertificateDescriptionX509DescriptionKeyUsageBaseKeyUsage) String 

func (r *CertificateCertificateDescriptionX509DescriptionKeyUsageBaseKeyUsage) String() string

func (*CertificateCertificateDescriptionX509DescriptionKeyUsageBaseKeyUsage) UnmarshalJSON 

func (r *CertificateCertificateDescriptionX509DescriptionKeyUsageBaseKeyUsage) UnmarshalJSON(data []byte) error

type CertificateCertificateDescriptionX509DescriptionKeyUsageExtendedKeyUsage 

type CertificateCertificateDescriptionX509DescriptionKeyUsageExtendedKeyUsage struct {
	ServerAuth      *bool `json:"serverAuth"`
	ClientAuth      *bool `json:"clientAuth"`
	CodeSigning     *bool `json:"codeSigning"`
	EmailProtection *bool `json:"emailProtection"`
	TimeStamping    *bool `json:"timeStamping"`
	OcspSigning     *bool `json:"ocspSigning"`
	// contains filtered or unexported fields
}
var EmptyCertificateCertificateDescriptionX509DescriptionKeyUsageExtendedKeyUsage *CertificateCertificateDescriptionX509DescriptionKeyUsageExtendedKeyUsage = &CertificateCertificateDescriptionX509DescriptionKeyUsageExtendedKeyUsage{empty: true}

This object is used to assert a desired state where this CertificateCertificateDescriptionX509DescriptionKeyUsageExtendedKeyUsage is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateCertificateDescriptionX509DescriptionKeyUsageExtendedKeyUsage) Empty 

func (r *CertificateCertificateDescriptionX509DescriptionKeyUsageExtendedKeyUsage) Empty() bool

func (*CertificateCertificateDescriptionX509DescriptionKeyUsageExtendedKeyUsage) HashCode 

func (r *CertificateCertificateDescriptionX509DescriptionKeyUsageExtendedKeyUsage) HashCode() string

func (*CertificateCertificateDescriptionX509DescriptionKeyUsageExtendedKeyUsage) String 

func (r *CertificateCertificateDescriptionX509DescriptionKeyUsageExtendedKeyUsage) String() string

func (*CertificateCertificateDescriptionX509DescriptionKeyUsageExtendedKeyUsage) UnmarshalJSON 

func (r *CertificateCertificateDescriptionX509DescriptionKeyUsageExtendedKeyUsage) UnmarshalJSON(data []byte) error

type CertificateCertificateDescriptionX509DescriptionKeyUsageUnknownExtendedKeyUsages 

type CertificateCertificateDescriptionX509DescriptionKeyUsageUnknownExtendedKeyUsages struct {
	ObjectIdPath []int64 `json:"objectIdPath"`
	// contains filtered or unexported fields
}
var EmptyCertificateCertificateDescriptionX509DescriptionKeyUsageUnknownExtendedKeyUsages *CertificateCertificateDescriptionX509DescriptionKeyUsageUnknownExtendedKeyUsages = &CertificateCertificateDescriptionX509DescriptionKeyUsageUnknownExtendedKeyUsages{empty: true}

This object is used to assert a desired state where this CertificateCertificateDescriptionX509DescriptionKeyUsageUnknownExtendedKeyUsages is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateCertificateDescriptionX509DescriptionKeyUsageUnknownExtendedKeyUsages) Empty 

func (r *CertificateCertificateDescriptionX509DescriptionKeyUsageUnknownExtendedKeyUsages) Empty() bool

func (*CertificateCertificateDescriptionX509DescriptionKeyUsageUnknownExtendedKeyUsages) HashCode 

func (r *CertificateCertificateDescriptionX509DescriptionKeyUsageUnknownExtendedKeyUsages) HashCode() string

func (*CertificateCertificateDescriptionX509DescriptionKeyUsageUnknownExtendedKeyUsages) String 

func (r *CertificateCertificateDescriptionX509DescriptionKeyUsageUnknownExtendedKeyUsages) String() string

func (*CertificateCertificateDescriptionX509DescriptionKeyUsageUnknownExtendedKeyUsages) UnmarshalJSON 

func (r *CertificateCertificateDescriptionX509DescriptionKeyUsageUnknownExtendedKeyUsages) UnmarshalJSON(data []byte) error

type CertificateCertificateDescriptionX509DescriptionPolicyIds 

type CertificateCertificateDescriptionX509DescriptionPolicyIds struct {
	ObjectIdPath []int64 `json:"objectIdPath"`
	// contains filtered or unexported fields
}
var EmptyCertificateCertificateDescriptionX509DescriptionPolicyIds *CertificateCertificateDescriptionX509DescriptionPolicyIds = &CertificateCertificateDescriptionX509DescriptionPolicyIds{empty: true}

This object is used to assert a desired state where this CertificateCertificateDescriptionX509DescriptionPolicyIds is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateCertificateDescriptionX509DescriptionPolicyIds) Empty 

func (r *CertificateCertificateDescriptionX509DescriptionPolicyIds) Empty() bool

func (*CertificateCertificateDescriptionX509DescriptionPolicyIds) HashCode 

func (r *CertificateCertificateDescriptionX509DescriptionPolicyIds) HashCode() string

func (*CertificateCertificateDescriptionX509DescriptionPolicyIds) String 

func (r *CertificateCertificateDescriptionX509DescriptionPolicyIds) String() string

func (*CertificateCertificateDescriptionX509DescriptionPolicyIds) UnmarshalJSON 

func (r *CertificateCertificateDescriptionX509DescriptionPolicyIds) UnmarshalJSON(data []byte) error

type CertificateConfig 

type CertificateConfig struct {
	SubjectConfig *CertificateConfigSubjectConfig `json:"subjectConfig"`
	X509Config    *CertificateConfigX509Config    `json:"x509Config"`
	PublicKey     *CertificateConfigPublicKey     `json:"publicKey"`
	// contains filtered or unexported fields
}
var EmptyCertificateConfig *CertificateConfig = &CertificateConfig{empty: true}

This object is used to assert a desired state where this CertificateConfig is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateConfig) Empty 

func (r *CertificateConfig) Empty() bool

func (*CertificateConfig) HashCode 

func (r *CertificateConfig) HashCode() string

func (*CertificateConfig) String 

func (r *CertificateConfig) String() string

func (*CertificateConfig) UnmarshalJSON 

func (r *CertificateConfig) UnmarshalJSON(data []byte) error

type CertificateConfigPublicKey 

type CertificateConfigPublicKey struct {
	Key    *string                               `json:"key"`
	Format *CertificateConfigPublicKeyFormatEnum `json:"format"`
	// contains filtered or unexported fields
}
var EmptyCertificateConfigPublicKey *CertificateConfigPublicKey = &CertificateConfigPublicKey{empty: true}

This object is used to assert a desired state where this CertificateConfigPublicKey is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateConfigPublicKey) Empty 

func (r *CertificateConfigPublicKey) Empty() bool

func (*CertificateConfigPublicKey) HashCode 

func (r *CertificateConfigPublicKey) HashCode() string

func (*CertificateConfigPublicKey) String 

func (r *CertificateConfigPublicKey) String() string

func (*CertificateConfigPublicKey) UnmarshalJSON 

func (r *CertificateConfigPublicKey) UnmarshalJSON(data []byte) error

type CertificateConfigPublicKeyFormatEnum 

type CertificateConfigPublicKeyFormatEnum string

The enum CertificateConfigPublicKeyFormatEnum.

func CertificateConfigPublicKeyFormatEnumRef 

func CertificateConfigPublicKeyFormatEnumRef(s string) *CertificateConfigPublicKeyFormatEnum

CertificateConfigPublicKeyFormatEnumRef returns a *CertificateConfigPublicKeyFormatEnum with the value of string s If the empty string is provided, nil is returned.

func (CertificateConfigPublicKeyFormatEnum) Validate 

func (v CertificateConfigPublicKeyFormatEnum) Validate() error

type CertificateConfigSubjectConfig 

type CertificateConfigSubjectConfig struct {
	Subject        *CertificateConfigSubjectConfigSubject        `json:"subject"`
	SubjectAltName *CertificateConfigSubjectConfigSubjectAltName `json:"subjectAltName"`
	// contains filtered or unexported fields
}
var EmptyCertificateConfigSubjectConfig *CertificateConfigSubjectConfig = &CertificateConfigSubjectConfig{empty: true}

This object is used to assert a desired state where this CertificateConfigSubjectConfig is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateConfigSubjectConfig) Empty 

func (r *CertificateConfigSubjectConfig) Empty() bool

func (*CertificateConfigSubjectConfig) HashCode 

func (r *CertificateConfigSubjectConfig) HashCode() string

func (*CertificateConfigSubjectConfig) String 

func (r *CertificateConfigSubjectConfig) String() string

func (*CertificateConfigSubjectConfig) UnmarshalJSON 

func (r *CertificateConfigSubjectConfig) UnmarshalJSON(data []byte) error

type CertificateConfigSubjectConfigSubject 

type CertificateConfigSubjectConfigSubject struct {
	CommonName         *string `json:"commonName"`
	CountryCode        *string `json:"countryCode"`
	Organization       *string `json:"organization"`
	OrganizationalUnit *string `json:"organizationalUnit"`
	Locality           *string `json:"locality"`
	Province           *string `json:"province"`
	StreetAddress      *string `json:"streetAddress"`
	PostalCode         *string `json:"postalCode"`
	// contains filtered or unexported fields
}
var EmptyCertificateConfigSubjectConfigSubject *CertificateConfigSubjectConfigSubject = &CertificateConfigSubjectConfigSubject{empty: true}

This object is used to assert a desired state where this CertificateConfigSubjectConfigSubject is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateConfigSubjectConfigSubject) Empty 

func (r *CertificateConfigSubjectConfigSubject) Empty() bool

func (*CertificateConfigSubjectConfigSubject) HashCode 

func (r *CertificateConfigSubjectConfigSubject) HashCode() string

func (*CertificateConfigSubjectConfigSubject) String 

func (r *CertificateConfigSubjectConfigSubject) String() string

func (*CertificateConfigSubjectConfigSubject) UnmarshalJSON 

func (r *CertificateConfigSubjectConfigSubject) UnmarshalJSON(data []byte) error

type CertificateConfigSubjectConfigSubjectAltName 

type CertificateConfigSubjectConfigSubjectAltName struct {
	DnsNames       []string `json:"dnsNames"`
	Uris           []string `json:"uris"`
	EmailAddresses []string `json:"emailAddresses"`
	IPAddresses    []string `json:"ipAddresses"`
	// contains filtered or unexported fields
}
var EmptyCertificateConfigSubjectConfigSubjectAltName *CertificateConfigSubjectConfigSubjectAltName = &CertificateConfigSubjectConfigSubjectAltName{empty: true}

This object is used to assert a desired state where this CertificateConfigSubjectConfigSubjectAltName is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateConfigSubjectConfigSubjectAltName) Empty 

func (r *CertificateConfigSubjectConfigSubjectAltName) Empty() bool

func (*CertificateConfigSubjectConfigSubjectAltName) HashCode 

func (r *CertificateConfigSubjectConfigSubjectAltName) HashCode() string

func (*CertificateConfigSubjectConfigSubjectAltName) String 

func (r *CertificateConfigSubjectConfigSubjectAltName) String() string

func (*CertificateConfigSubjectConfigSubjectAltName) UnmarshalJSON 

func (r *CertificateConfigSubjectConfigSubjectAltName) UnmarshalJSON(data []byte) error

type CertificateConfigX509Config 

type CertificateConfigX509Config struct {
	KeyUsage             *CertificateConfigX509ConfigKeyUsage              `json:"keyUsage"`
	CaOptions            *CertificateConfigX509ConfigCaOptions             `json:"caOptions"`
	PolicyIds            []CertificateConfigX509ConfigPolicyIds            `json:"policyIds"`
	AiaOcspServers       []string                                          `json:"aiaOcspServers"`
	AdditionalExtensions []CertificateConfigX509ConfigAdditionalExtensions `json:"additionalExtensions"`
	// contains filtered or unexported fields
}
var EmptyCertificateConfigX509Config *CertificateConfigX509Config = &CertificateConfigX509Config{empty: true}

This object is used to assert a desired state where this CertificateConfigX509Config is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateConfigX509Config) Empty 

func (r *CertificateConfigX509Config) Empty() bool

func (*CertificateConfigX509Config) HashCode 

func (r *CertificateConfigX509Config) HashCode() string

func (*CertificateConfigX509Config) String 

func (r *CertificateConfigX509Config) String() string

func (*CertificateConfigX509Config) UnmarshalJSON 

func (r *CertificateConfigX509Config) UnmarshalJSON(data []byte) error

type CertificateConfigX509ConfigAdditionalExtensions 

type CertificateConfigX509ConfigAdditionalExtensions struct {
	ObjectId *CertificateConfigX509ConfigAdditionalExtensionsObjectId `json:"objectId"`
	Critical *bool                                                    `json:"critical"`
	Value    *string                                                  `json:"value"`
	// contains filtered or unexported fields
}
var EmptyCertificateConfigX509ConfigAdditionalExtensions *CertificateConfigX509ConfigAdditionalExtensions = &CertificateConfigX509ConfigAdditionalExtensions{empty: true}

This object is used to assert a desired state where this CertificateConfigX509ConfigAdditionalExtensions is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateConfigX509ConfigAdditionalExtensions) Empty 

func (r *CertificateConfigX509ConfigAdditionalExtensions) Empty() bool

func (*CertificateConfigX509ConfigAdditionalExtensions) HashCode 

func (r *CertificateConfigX509ConfigAdditionalExtensions) HashCode() string

func (*CertificateConfigX509ConfigAdditionalExtensions) String 

func (r *CertificateConfigX509ConfigAdditionalExtensions) String() string

func (*CertificateConfigX509ConfigAdditionalExtensions) UnmarshalJSON 

func (r *CertificateConfigX509ConfigAdditionalExtensions) UnmarshalJSON(data []byte) error

type CertificateConfigX509ConfigAdditionalExtensionsObjectId 

type CertificateConfigX509ConfigAdditionalExtensionsObjectId struct {
	ObjectIdPath []int64 `json:"objectIdPath"`
	// contains filtered or unexported fields
}
var EmptyCertificateConfigX509ConfigAdditionalExtensionsObjectId *CertificateConfigX509ConfigAdditionalExtensionsObjectId = &CertificateConfigX509ConfigAdditionalExtensionsObjectId{empty: true}

This object is used to assert a desired state where this CertificateConfigX509ConfigAdditionalExtensionsObjectId is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateConfigX509ConfigAdditionalExtensionsObjectId) Empty 

func (r *CertificateConfigX509ConfigAdditionalExtensionsObjectId) Empty() bool

func (*CertificateConfigX509ConfigAdditionalExtensionsObjectId) HashCode 

func (r *CertificateConfigX509ConfigAdditionalExtensionsObjectId) HashCode() string

func (*CertificateConfigX509ConfigAdditionalExtensionsObjectId) String 

func (r *CertificateConfigX509ConfigAdditionalExtensionsObjectId) String() string

func (*CertificateConfigX509ConfigAdditionalExtensionsObjectId) UnmarshalJSON 

func (r *CertificateConfigX509ConfigAdditionalExtensionsObjectId) UnmarshalJSON(data []byte) error

type CertificateConfigX509ConfigCaOptions 

type CertificateConfigX509ConfigCaOptions struct {
	IsCa                    *bool  `json:"isCa"`
	NonCa                   *bool  `json:"nonCa"`
	MaxIssuerPathLength     *int64 `json:"maxIssuerPathLength"`
	ZeroMaxIssuerPathLength *bool  `json:"zeroMaxIssuerPathLength"`
	// contains filtered or unexported fields
}
var EmptyCertificateConfigX509ConfigCaOptions *CertificateConfigX509ConfigCaOptions = &CertificateConfigX509ConfigCaOptions{empty: true}

This object is used to assert a desired state where this CertificateConfigX509ConfigCaOptions is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateConfigX509ConfigCaOptions) Empty 

func (r *CertificateConfigX509ConfigCaOptions) Empty() bool

func (*CertificateConfigX509ConfigCaOptions) HashCode 

func (r *CertificateConfigX509ConfigCaOptions) HashCode() string

func (*CertificateConfigX509ConfigCaOptions) String 

func (r *CertificateConfigX509ConfigCaOptions) String() string

func (*CertificateConfigX509ConfigCaOptions) UnmarshalJSON 

func (r *CertificateConfigX509ConfigCaOptions) UnmarshalJSON(data []byte) error

type CertificateConfigX509ConfigKeyUsage 

type CertificateConfigX509ConfigKeyUsage struct {
	BaseKeyUsage             *CertificateConfigX509ConfigKeyUsageBaseKeyUsage              `json:"baseKeyUsage"`
	ExtendedKeyUsage         *CertificateConfigX509ConfigKeyUsageExtendedKeyUsage          `json:"extendedKeyUsage"`
	UnknownExtendedKeyUsages []CertificateConfigX509ConfigKeyUsageUnknownExtendedKeyUsages `json:"unknownExtendedKeyUsages"`
	// contains filtered or unexported fields
}
var EmptyCertificateConfigX509ConfigKeyUsage *CertificateConfigX509ConfigKeyUsage = &CertificateConfigX509ConfigKeyUsage{empty: true}

This object is used to assert a desired state where this CertificateConfigX509ConfigKeyUsage is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateConfigX509ConfigKeyUsage) Empty 

func (r *CertificateConfigX509ConfigKeyUsage) Empty() bool

func (*CertificateConfigX509ConfigKeyUsage) HashCode 

func (r *CertificateConfigX509ConfigKeyUsage) HashCode() string

func (*CertificateConfigX509ConfigKeyUsage) String 

func (r *CertificateConfigX509ConfigKeyUsage) String() string

func (*CertificateConfigX509ConfigKeyUsage) UnmarshalJSON 

func (r *CertificateConfigX509ConfigKeyUsage) UnmarshalJSON(data []byte) error

type CertificateConfigX509ConfigKeyUsageBaseKeyUsage 

type CertificateConfigX509ConfigKeyUsageBaseKeyUsage struct {
	DigitalSignature  *bool `json:"digitalSignature"`
	ContentCommitment *bool `json:"contentCommitment"`
	KeyEncipherment   *bool `json:"keyEncipherment"`
	DataEncipherment  *bool `json:"dataEncipherment"`
	KeyAgreement      *bool `json:"keyAgreement"`
	CertSign          *bool `json:"certSign"`
	CrlSign           *bool `json:"crlSign"`
	EncipherOnly      *bool `json:"encipherOnly"`
	DecipherOnly      *bool `json:"decipherOnly"`
	// contains filtered or unexported fields
}
var EmptyCertificateConfigX509ConfigKeyUsageBaseKeyUsage *CertificateConfigX509ConfigKeyUsageBaseKeyUsage = &CertificateConfigX509ConfigKeyUsageBaseKeyUsage{empty: true}

This object is used to assert a desired state where this CertificateConfigX509ConfigKeyUsageBaseKeyUsage is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateConfigX509ConfigKeyUsageBaseKeyUsage) Empty 

func (r *CertificateConfigX509ConfigKeyUsageBaseKeyUsage) Empty() bool

func (*CertificateConfigX509ConfigKeyUsageBaseKeyUsage) HashCode 

func (r *CertificateConfigX509ConfigKeyUsageBaseKeyUsage) HashCode() string

func (*CertificateConfigX509ConfigKeyUsageBaseKeyUsage) String 

func (r *CertificateConfigX509ConfigKeyUsageBaseKeyUsage) String() string

func (*CertificateConfigX509ConfigKeyUsageBaseKeyUsage) UnmarshalJSON 

func (r *CertificateConfigX509ConfigKeyUsageBaseKeyUsage) UnmarshalJSON(data []byte) error

type CertificateConfigX509ConfigKeyUsageExtendedKeyUsage 

type CertificateConfigX509ConfigKeyUsageExtendedKeyUsage struct {
	ServerAuth      *bool `json:"serverAuth"`
	ClientAuth      *bool `json:"clientAuth"`
	CodeSigning     *bool `json:"codeSigning"`
	EmailProtection *bool `json:"emailProtection"`
	TimeStamping    *bool `json:"timeStamping"`
	OcspSigning     *bool `json:"ocspSigning"`
	// contains filtered or unexported fields
}
var EmptyCertificateConfigX509ConfigKeyUsageExtendedKeyUsage *CertificateConfigX509ConfigKeyUsageExtendedKeyUsage = &CertificateConfigX509ConfigKeyUsageExtendedKeyUsage{empty: true}

This object is used to assert a desired state where this CertificateConfigX509ConfigKeyUsageExtendedKeyUsage is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateConfigX509ConfigKeyUsageExtendedKeyUsage) Empty 

func (r *CertificateConfigX509ConfigKeyUsageExtendedKeyUsage) Empty() bool

func (*CertificateConfigX509ConfigKeyUsageExtendedKeyUsage) HashCode 

func (r *CertificateConfigX509ConfigKeyUsageExtendedKeyUsage) HashCode() string

func (*CertificateConfigX509ConfigKeyUsageExtendedKeyUsage) String 

func (r *CertificateConfigX509ConfigKeyUsageExtendedKeyUsage) String() string

func (*CertificateConfigX509ConfigKeyUsageExtendedKeyUsage) UnmarshalJSON 

func (r *CertificateConfigX509ConfigKeyUsageExtendedKeyUsage) UnmarshalJSON(data []byte) error

type CertificateConfigX509ConfigKeyUsageUnknownExtendedKeyUsages 

type CertificateConfigX509ConfigKeyUsageUnknownExtendedKeyUsages struct {
	ObjectIdPath []int64 `json:"objectIdPath"`
	// contains filtered or unexported fields
}
var EmptyCertificateConfigX509ConfigKeyUsageUnknownExtendedKeyUsages *CertificateConfigX509ConfigKeyUsageUnknownExtendedKeyUsages = &CertificateConfigX509ConfigKeyUsageUnknownExtendedKeyUsages{empty: true}

This object is used to assert a desired state where this CertificateConfigX509ConfigKeyUsageUnknownExtendedKeyUsages is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateConfigX509ConfigKeyUsageUnknownExtendedKeyUsages) Empty 

func (r *CertificateConfigX509ConfigKeyUsageUnknownExtendedKeyUsages) Empty() bool

func (*CertificateConfigX509ConfigKeyUsageUnknownExtendedKeyUsages) HashCode 

func (r *CertificateConfigX509ConfigKeyUsageUnknownExtendedKeyUsages) HashCode() string

func (*CertificateConfigX509ConfigKeyUsageUnknownExtendedKeyUsages) String 

func (r *CertificateConfigX509ConfigKeyUsageUnknownExtendedKeyUsages) String() string

func (*CertificateConfigX509ConfigKeyUsageUnknownExtendedKeyUsages) UnmarshalJSON 

func (r *CertificateConfigX509ConfigKeyUsageUnknownExtendedKeyUsages) UnmarshalJSON(data []byte) error

type CertificateConfigX509ConfigPolicyIds 

type CertificateConfigX509ConfigPolicyIds struct {
	ObjectIdPath []int64 `json:"objectIdPath"`
	// contains filtered or unexported fields
}
var EmptyCertificateConfigX509ConfigPolicyIds *CertificateConfigX509ConfigPolicyIds = &CertificateConfigX509ConfigPolicyIds{empty: true}

This object is used to assert a desired state where this CertificateConfigX509ConfigPolicyIds is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateConfigX509ConfigPolicyIds) Empty 

func (r *CertificateConfigX509ConfigPolicyIds) Empty() bool

func (*CertificateConfigX509ConfigPolicyIds) HashCode 

func (r *CertificateConfigX509ConfigPolicyIds) HashCode() string

func (*CertificateConfigX509ConfigPolicyIds) String 

func (r *CertificateConfigX509ConfigPolicyIds) String() string

func (*CertificateConfigX509ConfigPolicyIds) UnmarshalJSON 

func (r *CertificateConfigX509ConfigPolicyIds) UnmarshalJSON(data []byte) error

type CertificateList 

type CertificateList struct {
	Items []*Certificate
	// contains filtered or unexported fields
}

func (*CertificateList) HasNext 

func (l *CertificateList) HasNext() bool

func (*CertificateList) Next 

func (l *CertificateList) Next(ctx context.Context, c *Client) error

type CertificateRevocationDetails 

type CertificateRevocationDetails struct {
	RevocationState *CertificateRevocationDetailsRevocationStateEnum `json:"revocationState"`
	RevocationTime  *string                                          `json:"revocationTime"`
	// contains filtered or unexported fields
}
var EmptyCertificateRevocationDetails *CertificateRevocationDetails = &CertificateRevocationDetails{empty: true}

This object is used to assert a desired state where this CertificateRevocationDetails is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateRevocationDetails) Empty 

func (r *CertificateRevocationDetails) Empty() bool

func (*CertificateRevocationDetails) HashCode 

func (r *CertificateRevocationDetails) HashCode() string

func (*CertificateRevocationDetails) String 

func (r *CertificateRevocationDetails) String() string

func (*CertificateRevocationDetails) UnmarshalJSON 

func (r *CertificateRevocationDetails) UnmarshalJSON(data []byte) error

type CertificateRevocationDetailsRevocationStateEnum 

type CertificateRevocationDetailsRevocationStateEnum string

The enum CertificateRevocationDetailsRevocationStateEnum.

func CertificateRevocationDetailsRevocationStateEnumRef 

func CertificateRevocationDetailsRevocationStateEnumRef(s string) *CertificateRevocationDetailsRevocationStateEnum

CertificateRevocationDetailsRevocationStateEnumRef returns a *CertificateRevocationDetailsRevocationStateEnum with the value of string s If the empty string is provided, nil is returned.

func (CertificateRevocationDetailsRevocationStateEnum) Validate 

func (v CertificateRevocationDetailsRevocationStateEnum) Validate() error

type CertificateSubjectModeEnum 

type CertificateSubjectModeEnum string

The enum CertificateSubjectModeEnum.

func CertificateSubjectModeEnumRef 

func CertificateSubjectModeEnumRef(s string) *CertificateSubjectModeEnum

CertificateSubjectModeEnumRef returns a *CertificateSubjectModeEnum with the value of string s If the empty string is provided, nil is returned.

func (CertificateSubjectModeEnum) Validate 

func (v CertificateSubjectModeEnum) Validate() error

type CertificateTemplate 

type CertificateTemplate struct {
	Name                  *string                                   `json:"name"`
	PredefinedValues      *CertificateTemplatePredefinedValues      `json:"predefinedValues"`
	IdentityConstraints   *CertificateTemplateIdentityConstraints   `json:"identityConstraints"`
	PassthroughExtensions *CertificateTemplatePassthroughExtensions `json:"passthroughExtensions"`
	MaximumLifetime       *string                                   `json:"maximumLifetime"`
	Description           *string                                   `json:"description"`
	CreateTime            *string                                   `json:"createTime"`
	UpdateTime            *string                                   `json:"updateTime"`
	Labels                map[string]string                         `json:"labels"`
	Project               *string                                   `json:"project"`
	Location              *string                                   `json:"location"`
}

func (*CertificateTemplate) Describe 

func (r *CertificateTemplate) Describe() dcl.ServiceTypeVersion

Describe returns a simple description of this resource to ensure that automated tools can identify it.

func (*CertificateTemplate) ID 

func (r *CertificateTemplate) ID() (string, error)

func (*CertificateTemplate) String 

func (r *CertificateTemplate) String() string

type CertificateTemplateIdentityConstraints 

type CertificateTemplateIdentityConstraints struct {
	CelExpression                   *CertificateTemplateIdentityConstraintsCelExpression `json:"celExpression"`
	AllowSubjectPassthrough         *bool                                                `json:"allowSubjectPassthrough"`
	AllowSubjectAltNamesPassthrough *bool                                                `json:"allowSubjectAltNamesPassthrough"`
	// contains filtered or unexported fields
}
var EmptyCertificateTemplateIdentityConstraints *CertificateTemplateIdentityConstraints = &CertificateTemplateIdentityConstraints{empty: true}

This object is used to assert a desired state where this CertificateTemplateIdentityConstraints is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateTemplateIdentityConstraints) Empty 

func (r *CertificateTemplateIdentityConstraints) Empty() bool

func (*CertificateTemplateIdentityConstraints) HashCode 

func (r *CertificateTemplateIdentityConstraints) HashCode() string

func (*CertificateTemplateIdentityConstraints) String 

func (r *CertificateTemplateIdentityConstraints) String() string

func (*CertificateTemplateIdentityConstraints) UnmarshalJSON 

func (r *CertificateTemplateIdentityConstraints) UnmarshalJSON(data []byte) error

type CertificateTemplateIdentityConstraintsCelExpression 

type CertificateTemplateIdentityConstraintsCelExpression struct {
	Expression  *string `json:"expression"`
	Title       *string `json:"title"`
	Description *string `json:"description"`
	Location    *string `json:"location"`
	// contains filtered or unexported fields
}
var EmptyCertificateTemplateIdentityConstraintsCelExpression *CertificateTemplateIdentityConstraintsCelExpression = &CertificateTemplateIdentityConstraintsCelExpression{empty: true}

This object is used to assert a desired state where this CertificateTemplateIdentityConstraintsCelExpression is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateTemplateIdentityConstraintsCelExpression) Empty 

func (r *CertificateTemplateIdentityConstraintsCelExpression) Empty() bool

func (*CertificateTemplateIdentityConstraintsCelExpression) HashCode 

func (r *CertificateTemplateIdentityConstraintsCelExpression) HashCode() string

func (*CertificateTemplateIdentityConstraintsCelExpression) String 

func (r *CertificateTemplateIdentityConstraintsCelExpression) String() string

func (*CertificateTemplateIdentityConstraintsCelExpression) UnmarshalJSON 

func (r *CertificateTemplateIdentityConstraintsCelExpression) UnmarshalJSON(data []byte) error

type CertificateTemplateList 

type CertificateTemplateList struct {
	Items []*CertificateTemplate
	// contains filtered or unexported fields
}

func (*CertificateTemplateList) HasNext 

func (l *CertificateTemplateList) HasNext() bool

func (*CertificateTemplateList) Next 

func (l *CertificateTemplateList) Next(ctx context.Context, c *Client) error

type CertificateTemplatePassthroughExtensions 

type CertificateTemplatePassthroughExtensions struct {
	KnownExtensions      []CertificateTemplatePassthroughExtensionsKnownExtensionsEnum  `json:"knownExtensions"`
	AdditionalExtensions []CertificateTemplatePassthroughExtensionsAdditionalExtensions `json:"additionalExtensions"`
	// contains filtered or unexported fields
}
var EmptyCertificateTemplatePassthroughExtensions *CertificateTemplatePassthroughExtensions = &CertificateTemplatePassthroughExtensions{empty: true}

This object is used to assert a desired state where this CertificateTemplatePassthroughExtensions is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateTemplatePassthroughExtensions) Empty 

func (r *CertificateTemplatePassthroughExtensions) Empty() bool

func (*CertificateTemplatePassthroughExtensions) HashCode 

func (r *CertificateTemplatePassthroughExtensions) HashCode() string

func (*CertificateTemplatePassthroughExtensions) String 

func (r *CertificateTemplatePassthroughExtensions) String() string

func (*CertificateTemplatePassthroughExtensions) UnmarshalJSON 

func (r *CertificateTemplatePassthroughExtensions) UnmarshalJSON(data []byte) error

type CertificateTemplatePassthroughExtensionsAdditionalExtensions 

type CertificateTemplatePassthroughExtensionsAdditionalExtensions struct {
	ObjectIdPath []int64 `json:"objectIdPath"`
	// contains filtered or unexported fields
}
var EmptyCertificateTemplatePassthroughExtensionsAdditionalExtensions *CertificateTemplatePassthroughExtensionsAdditionalExtensions = &CertificateTemplatePassthroughExtensionsAdditionalExtensions{empty: true}

This object is used to assert a desired state where this CertificateTemplatePassthroughExtensionsAdditionalExtensions is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateTemplatePassthroughExtensionsAdditionalExtensions) Empty 

func (r *CertificateTemplatePassthroughExtensionsAdditionalExtensions) Empty() bool

func (*CertificateTemplatePassthroughExtensionsAdditionalExtensions) HashCode 

func (r *CertificateTemplatePassthroughExtensionsAdditionalExtensions) HashCode() string

func (*CertificateTemplatePassthroughExtensionsAdditionalExtensions) String 

func (r *CertificateTemplatePassthroughExtensionsAdditionalExtensions) String() string

func (*CertificateTemplatePassthroughExtensionsAdditionalExtensions) UnmarshalJSON 

func (r *CertificateTemplatePassthroughExtensionsAdditionalExtensions) UnmarshalJSON(data []byte) error

type CertificateTemplatePassthroughExtensionsKnownExtensionsEnum 

type CertificateTemplatePassthroughExtensionsKnownExtensionsEnum string

The enum CertificateTemplatePassthroughExtensionsKnownExtensionsEnum.

func CertificateTemplatePassthroughExtensionsKnownExtensionsEnumRef 

func CertificateTemplatePassthroughExtensionsKnownExtensionsEnumRef(s string) *CertificateTemplatePassthroughExtensionsKnownExtensionsEnum

CertificateTemplatePassthroughExtensionsKnownExtensionsEnumRef returns a *CertificateTemplatePassthroughExtensionsKnownExtensionsEnum with the value of string s If the empty string is provided, nil is returned.

func (CertificateTemplatePassthroughExtensionsKnownExtensionsEnum) Validate 

func (v CertificateTemplatePassthroughExtensionsKnownExtensionsEnum) Validate() error

type CertificateTemplatePredefinedValues 

type CertificateTemplatePredefinedValues struct {
	KeyUsage             *CertificateTemplatePredefinedValuesKeyUsage              `json:"keyUsage"`
	CaOptions            *CertificateTemplatePredefinedValuesCaOptions             `json:"caOptions"`
	PolicyIds            []CertificateTemplatePredefinedValuesPolicyIds            `json:"policyIds"`
	AiaOcspServers       []string                                                  `json:"aiaOcspServers"`
	AdditionalExtensions []CertificateTemplatePredefinedValuesAdditionalExtensions `json:"additionalExtensions"`
	// contains filtered or unexported fields
}
var EmptyCertificateTemplatePredefinedValues *CertificateTemplatePredefinedValues = &CertificateTemplatePredefinedValues{empty: true}

This object is used to assert a desired state where this CertificateTemplatePredefinedValues is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateTemplatePredefinedValues) Empty 

func (r *CertificateTemplatePredefinedValues) Empty() bool

func (*CertificateTemplatePredefinedValues) HashCode 

func (r *CertificateTemplatePredefinedValues) HashCode() string

func (*CertificateTemplatePredefinedValues) String 

func (r *CertificateTemplatePredefinedValues) String() string

func (*CertificateTemplatePredefinedValues) UnmarshalJSON 

func (r *CertificateTemplatePredefinedValues) UnmarshalJSON(data []byte) error

type CertificateTemplatePredefinedValuesAdditionalExtensions 

type CertificateTemplatePredefinedValuesAdditionalExtensions struct {
	ObjectId *CertificateTemplatePredefinedValuesAdditionalExtensionsObjectId `json:"objectId"`
	Critical *bool                                                            `json:"critical"`
	Value    *string                                                          `json:"value"`
	// contains filtered or unexported fields
}
var EmptyCertificateTemplatePredefinedValuesAdditionalExtensions *CertificateTemplatePredefinedValuesAdditionalExtensions = &CertificateTemplatePredefinedValuesAdditionalExtensions{empty: true}

This object is used to assert a desired state where this CertificateTemplatePredefinedValuesAdditionalExtensions is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateTemplatePredefinedValuesAdditionalExtensions) Empty 

func (r *CertificateTemplatePredefinedValuesAdditionalExtensions) Empty() bool

func (*CertificateTemplatePredefinedValuesAdditionalExtensions) HashCode 

func (r *CertificateTemplatePredefinedValuesAdditionalExtensions) HashCode() string

func (*CertificateTemplatePredefinedValuesAdditionalExtensions) String 

func (r *CertificateTemplatePredefinedValuesAdditionalExtensions) String() string

func (*CertificateTemplatePredefinedValuesAdditionalExtensions) UnmarshalJSON 

func (r *CertificateTemplatePredefinedValuesAdditionalExtensions) UnmarshalJSON(data []byte) error

type CertificateTemplatePredefinedValuesAdditionalExtensionsObjectId 

type CertificateTemplatePredefinedValuesAdditionalExtensionsObjectId struct {
	ObjectIdPath []int64 `json:"objectIdPath"`
	// contains filtered or unexported fields
}
var EmptyCertificateTemplatePredefinedValuesAdditionalExtensionsObjectId *CertificateTemplatePredefinedValuesAdditionalExtensionsObjectId = &CertificateTemplatePredefinedValuesAdditionalExtensionsObjectId{empty: true}

This object is used to assert a desired state where this CertificateTemplatePredefinedValuesAdditionalExtensionsObjectId is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateTemplatePredefinedValuesAdditionalExtensionsObjectId) Empty 

func (r *CertificateTemplatePredefinedValuesAdditionalExtensionsObjectId) Empty() bool

func (*CertificateTemplatePredefinedValuesAdditionalExtensionsObjectId) HashCode 

func (r *CertificateTemplatePredefinedValuesAdditionalExtensionsObjectId) HashCode() string

func (*CertificateTemplatePredefinedValuesAdditionalExtensionsObjectId) String 

func (r *CertificateTemplatePredefinedValuesAdditionalExtensionsObjectId) String() string

func (*CertificateTemplatePredefinedValuesAdditionalExtensionsObjectId) UnmarshalJSON 

func (r *CertificateTemplatePredefinedValuesAdditionalExtensionsObjectId) UnmarshalJSON(data []byte) error

type CertificateTemplatePredefinedValuesCaOptions 

type CertificateTemplatePredefinedValuesCaOptions struct {
	IsCa                *bool  `json:"isCa"`
	MaxIssuerPathLength *int64 `json:"maxIssuerPathLength"`
	// contains filtered or unexported fields
}
var EmptyCertificateTemplatePredefinedValuesCaOptions *CertificateTemplatePredefinedValuesCaOptions = &CertificateTemplatePredefinedValuesCaOptions{empty: true}

This object is used to assert a desired state where this CertificateTemplatePredefinedValuesCaOptions is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateTemplatePredefinedValuesCaOptions) Empty 

func (r *CertificateTemplatePredefinedValuesCaOptions) Empty() bool

func (*CertificateTemplatePredefinedValuesCaOptions) HashCode 

func (r *CertificateTemplatePredefinedValuesCaOptions) HashCode() string

func (*CertificateTemplatePredefinedValuesCaOptions) String 

func (r *CertificateTemplatePredefinedValuesCaOptions) String() string

func (*CertificateTemplatePredefinedValuesCaOptions) UnmarshalJSON 

func (r *CertificateTemplatePredefinedValuesCaOptions) UnmarshalJSON(data []byte) error

type CertificateTemplatePredefinedValuesKeyUsage 

type CertificateTemplatePredefinedValuesKeyUsage struct {
	BaseKeyUsage             *CertificateTemplatePredefinedValuesKeyUsageBaseKeyUsage              `json:"baseKeyUsage"`
	ExtendedKeyUsage         *CertificateTemplatePredefinedValuesKeyUsageExtendedKeyUsage          `json:"extendedKeyUsage"`
	UnknownExtendedKeyUsages []CertificateTemplatePredefinedValuesKeyUsageUnknownExtendedKeyUsages `json:"unknownExtendedKeyUsages"`
	// contains filtered or unexported fields
}
var EmptyCertificateTemplatePredefinedValuesKeyUsage *CertificateTemplatePredefinedValuesKeyUsage = &CertificateTemplatePredefinedValuesKeyUsage{empty: true}

This object is used to assert a desired state where this CertificateTemplatePredefinedValuesKeyUsage is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateTemplatePredefinedValuesKeyUsage) Empty 

func (r *CertificateTemplatePredefinedValuesKeyUsage) Empty() bool

func (*CertificateTemplatePredefinedValuesKeyUsage) HashCode 

func (r *CertificateTemplatePredefinedValuesKeyUsage) HashCode() string

func (*CertificateTemplatePredefinedValuesKeyUsage) String 

func (r *CertificateTemplatePredefinedValuesKeyUsage) String() string

func (*CertificateTemplatePredefinedValuesKeyUsage) UnmarshalJSON 

func (r *CertificateTemplatePredefinedValuesKeyUsage) UnmarshalJSON(data []byte) error

type CertificateTemplatePredefinedValuesKeyUsageBaseKeyUsage 

type CertificateTemplatePredefinedValuesKeyUsageBaseKeyUsage struct {
	DigitalSignature  *bool `json:"digitalSignature"`
	ContentCommitment *bool `json:"contentCommitment"`
	KeyEncipherment   *bool `json:"keyEncipherment"`
	DataEncipherment  *bool `json:"dataEncipherment"`
	KeyAgreement      *bool `json:"keyAgreement"`
	CertSign          *bool `json:"certSign"`
	CrlSign           *bool `json:"crlSign"`
	EncipherOnly      *bool `json:"encipherOnly"`
	DecipherOnly      *bool `json:"decipherOnly"`
	// contains filtered or unexported fields
}
var EmptyCertificateTemplatePredefinedValuesKeyUsageBaseKeyUsage *CertificateTemplatePredefinedValuesKeyUsageBaseKeyUsage = &CertificateTemplatePredefinedValuesKeyUsageBaseKeyUsage{empty: true}

This object is used to assert a desired state where this CertificateTemplatePredefinedValuesKeyUsageBaseKeyUsage is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateTemplatePredefinedValuesKeyUsageBaseKeyUsage) Empty 

func (r *CertificateTemplatePredefinedValuesKeyUsageBaseKeyUsage) Empty() bool

func (*CertificateTemplatePredefinedValuesKeyUsageBaseKeyUsage) HashCode 

func (r *CertificateTemplatePredefinedValuesKeyUsageBaseKeyUsage) HashCode() string

func (*CertificateTemplatePredefinedValuesKeyUsageBaseKeyUsage) String 

func (r *CertificateTemplatePredefinedValuesKeyUsageBaseKeyUsage) String() string

func (*CertificateTemplatePredefinedValuesKeyUsageBaseKeyUsage) UnmarshalJSON 

func (r *CertificateTemplatePredefinedValuesKeyUsageBaseKeyUsage) UnmarshalJSON(data []byte) error

type CertificateTemplatePredefinedValuesKeyUsageExtendedKeyUsage 

type CertificateTemplatePredefinedValuesKeyUsageExtendedKeyUsage struct {
	ServerAuth      *bool `json:"serverAuth"`
	ClientAuth      *bool `json:"clientAuth"`
	CodeSigning     *bool `json:"codeSigning"`
	EmailProtection *bool `json:"emailProtection"`
	TimeStamping    *bool `json:"timeStamping"`
	OcspSigning     *bool `json:"ocspSigning"`
	// contains filtered or unexported fields
}
var EmptyCertificateTemplatePredefinedValuesKeyUsageExtendedKeyUsage *CertificateTemplatePredefinedValuesKeyUsageExtendedKeyUsage = &CertificateTemplatePredefinedValuesKeyUsageExtendedKeyUsage{empty: true}

This object is used to assert a desired state where this CertificateTemplatePredefinedValuesKeyUsageExtendedKeyUsage is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateTemplatePredefinedValuesKeyUsageExtendedKeyUsage) Empty 

func (r *CertificateTemplatePredefinedValuesKeyUsageExtendedKeyUsage) Empty() bool

func (*CertificateTemplatePredefinedValuesKeyUsageExtendedKeyUsage) HashCode 

func (r *CertificateTemplatePredefinedValuesKeyUsageExtendedKeyUsage) HashCode() string

func (*CertificateTemplatePredefinedValuesKeyUsageExtendedKeyUsage) String 

func (r *CertificateTemplatePredefinedValuesKeyUsageExtendedKeyUsage) String() string

func (*CertificateTemplatePredefinedValuesKeyUsageExtendedKeyUsage) UnmarshalJSON 

func (r *CertificateTemplatePredefinedValuesKeyUsageExtendedKeyUsage) UnmarshalJSON(data []byte) error

type CertificateTemplatePredefinedValuesKeyUsageUnknownExtendedKeyUsages 

type CertificateTemplatePredefinedValuesKeyUsageUnknownExtendedKeyUsages struct {
	ObjectIdPath []int64 `json:"objectIdPath"`
	// contains filtered or unexported fields
}
var EmptyCertificateTemplatePredefinedValuesKeyUsageUnknownExtendedKeyUsages *CertificateTemplatePredefinedValuesKeyUsageUnknownExtendedKeyUsages = &CertificateTemplatePredefinedValuesKeyUsageUnknownExtendedKeyUsages{empty: true}

This object is used to assert a desired state where this CertificateTemplatePredefinedValuesKeyUsageUnknownExtendedKeyUsages is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateTemplatePredefinedValuesKeyUsageUnknownExtendedKeyUsages) Empty 

func (r *CertificateTemplatePredefinedValuesKeyUsageUnknownExtendedKeyUsages) Empty() bool

func (*CertificateTemplatePredefinedValuesKeyUsageUnknownExtendedKeyUsages) HashCode 

func (r *CertificateTemplatePredefinedValuesKeyUsageUnknownExtendedKeyUsages) HashCode() string

func (*CertificateTemplatePredefinedValuesKeyUsageUnknownExtendedKeyUsages) String 

func (r *CertificateTemplatePredefinedValuesKeyUsageUnknownExtendedKeyUsages) String() string

func (*CertificateTemplatePredefinedValuesKeyUsageUnknownExtendedKeyUsages) UnmarshalJSON 

func (r *CertificateTemplatePredefinedValuesKeyUsageUnknownExtendedKeyUsages) UnmarshalJSON(data []byte) error

type CertificateTemplatePredefinedValuesPolicyIds 

type CertificateTemplatePredefinedValuesPolicyIds struct {
	ObjectIdPath []int64 `json:"objectIdPath"`
	// contains filtered or unexported fields
}
var EmptyCertificateTemplatePredefinedValuesPolicyIds *CertificateTemplatePredefinedValuesPolicyIds = &CertificateTemplatePredefinedValuesPolicyIds{empty: true}

This object is used to assert a desired state where this CertificateTemplatePredefinedValuesPolicyIds is empty. Go lacks global const objects, but this object should be treated as one. Modifying this object will have undesirable results.

func (*CertificateTemplatePredefinedValuesPolicyIds) Empty 

func (r *CertificateTemplatePredefinedValuesPolicyIds) Empty() bool

func (*CertificateTemplatePredefinedValuesPolicyIds) HashCode 

func (r *CertificateTemplatePredefinedValuesPolicyIds) HashCode() string

func (*CertificateTemplatePredefinedValuesPolicyIds) String 

func (r *CertificateTemplatePredefinedValuesPolicyIds) String() string

func (*CertificateTemplatePredefinedValuesPolicyIds) UnmarshalJSON 

func (r *CertificateTemplatePredefinedValuesPolicyIds) UnmarshalJSON(data []byte) error

type Client 

type Client struct {
	Config *dcl.Config
}

The Client is the base struct of all operations. This will receive the Get, Delete, List, and Apply operations on all resources.

func NewClient 

func NewClient(c *dcl.Config) *Client

NewClient creates a client that retries all operations a few times each.

func (*Client) ApplyCaPool 

func (c *Client) ApplyCaPool(ctx context.Context, rawDesired *CaPool, opts ...dcl.ApplyOption) (*CaPool, error)

func (*Client) ApplyCertificate 

func (c *Client) ApplyCertificate(ctx context.Context, rawDesired *Certificate, opts ...dcl.ApplyOption) (*Certificate, error)

func (*Client) ApplyCertificateAuthority 

func (c *Client) ApplyCertificateAuthority(ctx context.Context, rawDesired *CertificateAuthority, opts ...dcl.ApplyOption) (*CertificateAuthority, error)

func (*Client) ApplyCertificateTemplate 

func (c *Client) ApplyCertificateTemplate(ctx context.Context, rawDesired *CertificateTemplate, opts ...dcl.ApplyOption) (*CertificateTemplate, error)

func (*Client) DeleteAllCaPool 

func (c *Client) DeleteAllCaPool(ctx context.Context, project, location string, filter func(*CaPool) bool) error

DeleteAllCaPool deletes all resources that the filter functions returns true on.

func (*Client) DeleteAllCertificate 

func (c *Client) DeleteAllCertificate(ctx context.Context, project, location, caPool string, filter func(*Certificate) bool) error

DeleteAllCertificate deletes all resources that the filter functions returns true on.

func (*Client) DeleteAllCertificateAuthority 

func (c *Client) DeleteAllCertificateAuthority(ctx context.Context, project, location, caPool string, filter func(*CertificateAuthority) bool) error

DeleteAllCertificateAuthority deletes all resources that the filter functions returns true on.

func (*Client) DeleteAllCertificateTemplate 

func (c *Client) DeleteAllCertificateTemplate(ctx context.Context, project, location string, filter func(*CertificateTemplate) bool) error

DeleteAllCertificateTemplate deletes all resources that the filter functions returns true on.

func (*Client) DeleteCaPool 

func (c *Client) DeleteCaPool(ctx context.Context, r *CaPool) error

func (*Client) DeleteCertificate 

func (c *Client) DeleteCertificate(ctx context.Context, r *Certificate) error

func (*Client) DeleteCertificateAuthority 

func (c *Client) DeleteCertificateAuthority(ctx context.Context, r *CertificateAuthority) error

func (*Client) DeleteCertificateTemplate 

func (c *Client) DeleteCertificateTemplate(ctx context.Context, r *CertificateTemplate) error

func (*Client) GetCaPool 

func (c *Client) GetCaPool(ctx context.Context, r *CaPool) (*CaPool, error)

func (*Client) GetCertificate 

func (c *Client) GetCertificate(ctx context.Context, r *Certificate) (*Certificate, error)

func (*Client) GetCertificateAuthority 

func (c *Client) GetCertificateAuthority(ctx context.Context, r *CertificateAuthority) (*CertificateAuthority, error)

func (*Client) GetCertificateTemplate 

func (c *Client) GetCertificateTemplate(ctx context.Context, r *CertificateTemplate) (*CertificateTemplate, error)

func (*Client) ListCaPool 

func (c *Client) ListCaPool(ctx context.Context, project, location string) (*CaPoolList, error)

func (*Client) ListCaPoolWithMaxResults 

func (c *Client) ListCaPoolWithMaxResults(ctx context.Context, project, location string, pageSize int32) (*CaPoolList, error)

func (*Client) ListCertificate 

func (c *Client) ListCertificate(ctx context.Context, project, location, caPool string) (*CertificateList, error)

func (*Client) ListCertificateAuthority 

func (c *Client) ListCertificateAuthority(ctx context.Context, project, location, caPool string) (*CertificateAuthorityList, error)

func (*Client) ListCertificateAuthorityWithMaxResults 

func (c *Client) ListCertificateAuthorityWithMaxResults(ctx context.Context, project, location, caPool string, pageSize int32) (*CertificateAuthorityList, error)

func (*Client) ListCertificateTemplate 

func (c *Client) ListCertificateTemplate(ctx context.Context, project, location string) (*CertificateTemplateList, error)

func (*Client) ListCertificateTemplateWithMaxResults 

func (c *Client) ListCertificateTemplateWithMaxResults(ctx context.Context, project, location string, pageSize int32) (*CertificateTemplateList, error)

func (*Client) ListCertificateWithMaxResults 

func (c *Client) ListCertificateWithMaxResults(ctx context.Context, project, location, caPool string, pageSize int32) (*CertificateList, error)

Source Files

View all Source files

Jump to

Keyboard shortcuts

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