beta

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: 1

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. Package beta 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.

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 osconfig defines types and functions for managing osconfig GCP resources.

Index

Constants

View Source 
const GuestPolicyMaxPage = -1
View Source 
const OSPolicyAssignmentMaxPage = -1

Variables

View Source 
var YAML_guest_policy []byte
View Source 
var YAML_os_policy_assignment []byte

Functions

func DCLGuestPolicySchema added in v1.10.3 

func DCLGuestPolicySchema() *dcl.Schema

func DCLOSPolicyAssignmentSchema added in v1.10.3 

func DCLOSPolicyAssignmentSchema() *dcl.Schema

Types

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) ApplyGuestPolicy 

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

func (*Client) ApplyOSPolicyAssignment 

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

func (*Client) DeleteAllGuestPolicy 

func (c *Client) DeleteAllGuestPolicy(ctx context.Context, project string, filter func(*GuestPolicy) bool) error

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

func (*Client) DeleteAllOSPolicyAssignment 

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

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

func (*Client) DeleteGuestPolicy 

func (c *Client) DeleteGuestPolicy(ctx context.Context, r *GuestPolicy) error

func (*Client) DeleteOSPolicyAssignment 

func (c *Client) DeleteOSPolicyAssignment(ctx context.Context, r *OSPolicyAssignment) error

func (*Client) GetGuestPolicy 

func (c *Client) GetGuestPolicy(ctx context.Context, r *GuestPolicy) (*GuestPolicy, error)

func (*Client) GetOSPolicyAssignment 

func (c *Client) GetOSPolicyAssignment(ctx context.Context, r *OSPolicyAssignment) (*OSPolicyAssignment, error)

func (*Client) ListGuestPolicy 

func (c *Client) ListGuestPolicy(ctx context.Context, project string) (*GuestPolicyList, error)

func (*Client) ListGuestPolicyWithMaxResults 

func (c *Client) ListGuestPolicyWithMaxResults(ctx context.Context, project string, pageSize int32) (*GuestPolicyList, error)

func (*Client) ListOSPolicyAssignment 

func (c *Client) ListOSPolicyAssignment(ctx context.Context, project, location string) (*OSPolicyAssignmentList, error)

func (*Client) ListOSPolicyAssignmentWithMaxResults 

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

type GuestPolicy 

type GuestPolicy struct {
	Name                *string                          `json:"name"`
	Description         *string                          `json:"description"`
	CreateTime          *string                          `json:"createTime"`
	UpdateTime          *string                          `json:"updateTime"`
	Assignment          *GuestPolicyAssignment           `json:"assignment"`
	Packages            []GuestPolicyPackages            `json:"packages"`
	PackageRepositories []GuestPolicyPackageRepositories `json:"packageRepositories"`
	Recipes             []GuestPolicyRecipes             `json:"recipes"`
	Etag                *string                          `json:"etag"`
	Project             *string                          `json:"project"`
}

func (*GuestPolicy) Describe 

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

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

func (*GuestPolicy) ID 

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

func (*GuestPolicy) String 

func (r *GuestPolicy) String() string

type GuestPolicyAssignment 

type GuestPolicyAssignment struct {
	GroupLabels          []GuestPolicyAssignmentGroupLabels `json:"groupLabels"`
	Zones                []string                           `json:"zones"`
	Instances            []string                           `json:"instances"`
	InstanceNamePrefixes []string                           `json:"instanceNamePrefixes"`
	OSTypes              []GuestPolicyAssignmentOSTypes     `json:"osTypes"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyAssignment *GuestPolicyAssignment = &GuestPolicyAssignment{empty: true}

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

func (*GuestPolicyAssignment) Empty 

func (r *GuestPolicyAssignment) Empty() bool

func (*GuestPolicyAssignment) HashCode 

func (r *GuestPolicyAssignment) HashCode() string

func (*GuestPolicyAssignment) String 

func (r *GuestPolicyAssignment) String() string

func (*GuestPolicyAssignment) UnmarshalJSON 

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

type GuestPolicyAssignmentGroupLabels 

type GuestPolicyAssignmentGroupLabels struct {
	Labels map[string]string `json:"labels"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyAssignmentGroupLabels *GuestPolicyAssignmentGroupLabels = &GuestPolicyAssignmentGroupLabels{empty: true}

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

func (*GuestPolicyAssignmentGroupLabels) Empty 

func (r *GuestPolicyAssignmentGroupLabels) Empty() bool

func (*GuestPolicyAssignmentGroupLabels) HashCode 

func (r *GuestPolicyAssignmentGroupLabels) HashCode() string

func (*GuestPolicyAssignmentGroupLabels) String 

func (r *GuestPolicyAssignmentGroupLabels) String() string

func (*GuestPolicyAssignmentGroupLabels) UnmarshalJSON 

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

type GuestPolicyAssignmentOSTypes 

type GuestPolicyAssignmentOSTypes struct {
	OSShortName    *string `json:"osShortName"`
	OSVersion      *string `json:"osVersion"`
	OSArchitecture *string `json:"osArchitecture"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyAssignmentOSTypes *GuestPolicyAssignmentOSTypes = &GuestPolicyAssignmentOSTypes{empty: true}

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

func (*GuestPolicyAssignmentOSTypes) Empty 

func (r *GuestPolicyAssignmentOSTypes) Empty() bool

func (*GuestPolicyAssignmentOSTypes) HashCode 

func (r *GuestPolicyAssignmentOSTypes) HashCode() string

func (*GuestPolicyAssignmentOSTypes) String 

func (r *GuestPolicyAssignmentOSTypes) String() string

func (*GuestPolicyAssignmentOSTypes) UnmarshalJSON 

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

type GuestPolicyList 

type GuestPolicyList struct {
	Items []*GuestPolicy
	// contains filtered or unexported fields
}

func (*GuestPolicyList) HasNext 

func (l *GuestPolicyList) HasNext() bool

func (*GuestPolicyList) Next 

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

type GuestPolicyPackageRepositories 

type GuestPolicyPackageRepositories struct {
	Apt    *GuestPolicyPackageRepositoriesApt    `json:"apt"`
	Yum    *GuestPolicyPackageRepositoriesYum    `json:"yum"`
	Zypper *GuestPolicyPackageRepositoriesZypper `json:"zypper"`
	Goo    *GuestPolicyPackageRepositoriesGoo    `json:"goo"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyPackageRepositories *GuestPolicyPackageRepositories = &GuestPolicyPackageRepositories{empty: true}

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

func (*GuestPolicyPackageRepositories) Empty 

func (r *GuestPolicyPackageRepositories) Empty() bool

func (*GuestPolicyPackageRepositories) HashCode 

func (r *GuestPolicyPackageRepositories) HashCode() string

func (*GuestPolicyPackageRepositories) String 

func (r *GuestPolicyPackageRepositories) String() string

func (*GuestPolicyPackageRepositories) UnmarshalJSON 

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

type GuestPolicyPackageRepositoriesApt 

type GuestPolicyPackageRepositoriesApt struct {
	ArchiveType  *GuestPolicyPackageRepositoriesAptArchiveTypeEnum `json:"archiveType"`
	Uri          *string                                           `json:"uri"`
	Distribution *string                                           `json:"distribution"`
	Components   []string                                          `json:"components"`
	GpgKey       *string                                           `json:"gpgKey"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyPackageRepositoriesApt *GuestPolicyPackageRepositoriesApt = &GuestPolicyPackageRepositoriesApt{empty: true}

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

func (*GuestPolicyPackageRepositoriesApt) Empty 

func (r *GuestPolicyPackageRepositoriesApt) Empty() bool

func (*GuestPolicyPackageRepositoriesApt) HashCode 

func (r *GuestPolicyPackageRepositoriesApt) HashCode() string

func (*GuestPolicyPackageRepositoriesApt) String 

func (r *GuestPolicyPackageRepositoriesApt) String() string

func (*GuestPolicyPackageRepositoriesApt) UnmarshalJSON 

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

type GuestPolicyPackageRepositoriesAptArchiveTypeEnum 

type GuestPolicyPackageRepositoriesAptArchiveTypeEnum string

The enum GuestPolicyPackageRepositoriesAptArchiveTypeEnum.

func GuestPolicyPackageRepositoriesAptArchiveTypeEnumRef 

func GuestPolicyPackageRepositoriesAptArchiveTypeEnumRef(s string) *GuestPolicyPackageRepositoriesAptArchiveTypeEnum

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

func (GuestPolicyPackageRepositoriesAptArchiveTypeEnum) Validate 

func (v GuestPolicyPackageRepositoriesAptArchiveTypeEnum) Validate() error

type GuestPolicyPackageRepositoriesGoo 

type GuestPolicyPackageRepositoriesGoo struct {
	Name *string `json:"name"`
	Url  *string `json:"url"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyPackageRepositoriesGoo *GuestPolicyPackageRepositoriesGoo = &GuestPolicyPackageRepositoriesGoo{empty: true}

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

func (*GuestPolicyPackageRepositoriesGoo) Empty 

func (r *GuestPolicyPackageRepositoriesGoo) Empty() bool

func (*GuestPolicyPackageRepositoriesGoo) HashCode 

func (r *GuestPolicyPackageRepositoriesGoo) HashCode() string

func (*GuestPolicyPackageRepositoriesGoo) String 

func (r *GuestPolicyPackageRepositoriesGoo) String() string

func (*GuestPolicyPackageRepositoriesGoo) UnmarshalJSON 

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

type GuestPolicyPackageRepositoriesYum 

type GuestPolicyPackageRepositoriesYum struct {
	Id          *string  `json:"id"`
	DisplayName *string  `json:"displayName"`
	BaseUrl     *string  `json:"baseUrl"`
	GpgKeys     []string `json:"gpgKeys"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyPackageRepositoriesYum *GuestPolicyPackageRepositoriesYum = &GuestPolicyPackageRepositoriesYum{empty: true}

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

func (*GuestPolicyPackageRepositoriesYum) Empty 

func (r *GuestPolicyPackageRepositoriesYum) Empty() bool

func (*GuestPolicyPackageRepositoriesYum) HashCode 

func (r *GuestPolicyPackageRepositoriesYum) HashCode() string

func (*GuestPolicyPackageRepositoriesYum) String 

func (r *GuestPolicyPackageRepositoriesYum) String() string

func (*GuestPolicyPackageRepositoriesYum) UnmarshalJSON 

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

type GuestPolicyPackageRepositoriesZypper 

type GuestPolicyPackageRepositoriesZypper struct {
	Id          *string  `json:"id"`
	DisplayName *string  `json:"displayName"`
	BaseUrl     *string  `json:"baseUrl"`
	GpgKeys     []string `json:"gpgKeys"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyPackageRepositoriesZypper *GuestPolicyPackageRepositoriesZypper = &GuestPolicyPackageRepositoriesZypper{empty: true}

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

func (*GuestPolicyPackageRepositoriesZypper) Empty 

func (r *GuestPolicyPackageRepositoriesZypper) Empty() bool

func (*GuestPolicyPackageRepositoriesZypper) HashCode 

func (r *GuestPolicyPackageRepositoriesZypper) HashCode() string

func (*GuestPolicyPackageRepositoriesZypper) String 

func (r *GuestPolicyPackageRepositoriesZypper) String() string

func (*GuestPolicyPackageRepositoriesZypper) UnmarshalJSON 

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

type GuestPolicyPackages 

type GuestPolicyPackages struct {
	Name         *string                              `json:"name"`
	DesiredState *GuestPolicyPackagesDesiredStateEnum `json:"desiredState"`
	Manager      *GuestPolicyPackagesManagerEnum      `json:"manager"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyPackages *GuestPolicyPackages = &GuestPolicyPackages{empty: true}

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

func (*GuestPolicyPackages) Empty 

func (r *GuestPolicyPackages) Empty() bool

func (*GuestPolicyPackages) HashCode 

func (r *GuestPolicyPackages) HashCode() string

func (*GuestPolicyPackages) String 

func (r *GuestPolicyPackages) String() string

func (*GuestPolicyPackages) UnmarshalJSON 

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

type GuestPolicyPackagesDesiredStateEnum 

type GuestPolicyPackagesDesiredStateEnum string

The enum GuestPolicyPackagesDesiredStateEnum.

func GuestPolicyPackagesDesiredStateEnumRef 

func GuestPolicyPackagesDesiredStateEnumRef(s string) *GuestPolicyPackagesDesiredStateEnum

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

func (GuestPolicyPackagesDesiredStateEnum) Validate 

func (v GuestPolicyPackagesDesiredStateEnum) Validate() error

type GuestPolicyPackagesManagerEnum 

type GuestPolicyPackagesManagerEnum string

The enum GuestPolicyPackagesManagerEnum.

func GuestPolicyPackagesManagerEnumRef 

func GuestPolicyPackagesManagerEnumRef(s string) *GuestPolicyPackagesManagerEnum

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

func (GuestPolicyPackagesManagerEnum) Validate 

func (v GuestPolicyPackagesManagerEnum) Validate() error

type GuestPolicyRecipes 

type GuestPolicyRecipes struct {
	Name         *string                             `json:"name"`
	Version      *string                             `json:"version"`
	Artifacts    []GuestPolicyRecipesArtifacts       `json:"artifacts"`
	InstallSteps []GuestPolicyRecipesInstallSteps    `json:"installSteps"`
	UpdateSteps  []GuestPolicyRecipesUpdateSteps     `json:"updateSteps"`
	DesiredState *GuestPolicyRecipesDesiredStateEnum `json:"desiredState"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyRecipes *GuestPolicyRecipes = &GuestPolicyRecipes{empty: true}

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

func (*GuestPolicyRecipes) Empty 

func (r *GuestPolicyRecipes) Empty() bool

func (*GuestPolicyRecipes) HashCode 

func (r *GuestPolicyRecipes) HashCode() string

func (*GuestPolicyRecipes) String 

func (r *GuestPolicyRecipes) String() string

func (*GuestPolicyRecipes) UnmarshalJSON 

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

type GuestPolicyRecipesArtifacts 

type GuestPolicyRecipesArtifacts struct {
	Id            *string                            `json:"id"`
	Remote        *GuestPolicyRecipesArtifactsRemote `json:"remote"`
	Gcs           *GuestPolicyRecipesArtifactsGcs    `json:"gcs"`
	AllowInsecure *bool                              `json:"allowInsecure"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyRecipesArtifacts *GuestPolicyRecipesArtifacts = &GuestPolicyRecipesArtifacts{empty: true}

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

func (*GuestPolicyRecipesArtifacts) Empty 

func (r *GuestPolicyRecipesArtifacts) Empty() bool

func (*GuestPolicyRecipesArtifacts) HashCode 

func (r *GuestPolicyRecipesArtifacts) HashCode() string

func (*GuestPolicyRecipesArtifacts) String 

func (r *GuestPolicyRecipesArtifacts) String() string

func (*GuestPolicyRecipesArtifacts) UnmarshalJSON 

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

type GuestPolicyRecipesArtifactsGcs 

type GuestPolicyRecipesArtifactsGcs struct {
	Bucket     *string `json:"bucket"`
	Object     *string `json:"object"`
	Generation *int64  `json:"generation"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyRecipesArtifactsGcs *GuestPolicyRecipesArtifactsGcs = &GuestPolicyRecipesArtifactsGcs{empty: true}

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

func (*GuestPolicyRecipesArtifactsGcs) Empty 

func (r *GuestPolicyRecipesArtifactsGcs) Empty() bool

func (*GuestPolicyRecipesArtifactsGcs) HashCode 

func (r *GuestPolicyRecipesArtifactsGcs) HashCode() string

func (*GuestPolicyRecipesArtifactsGcs) String 

func (r *GuestPolicyRecipesArtifactsGcs) String() string

func (*GuestPolicyRecipesArtifactsGcs) UnmarshalJSON 

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

type GuestPolicyRecipesArtifactsRemote 

type GuestPolicyRecipesArtifactsRemote struct {
	Uri      *string `json:"uri"`
	Checksum *string `json:"checksum"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyRecipesArtifactsRemote *GuestPolicyRecipesArtifactsRemote = &GuestPolicyRecipesArtifactsRemote{empty: true}

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

func (*GuestPolicyRecipesArtifactsRemote) Empty 

func (r *GuestPolicyRecipesArtifactsRemote) Empty() bool

func (*GuestPolicyRecipesArtifactsRemote) HashCode 

func (r *GuestPolicyRecipesArtifactsRemote) HashCode() string

func (*GuestPolicyRecipesArtifactsRemote) String 

func (r *GuestPolicyRecipesArtifactsRemote) String() string

func (*GuestPolicyRecipesArtifactsRemote) UnmarshalJSON 

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

type GuestPolicyRecipesDesiredStateEnum 

type GuestPolicyRecipesDesiredStateEnum string

The enum GuestPolicyRecipesDesiredStateEnum.

func GuestPolicyRecipesDesiredStateEnumRef 

func GuestPolicyRecipesDesiredStateEnumRef(s string) *GuestPolicyRecipesDesiredStateEnum

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

func (GuestPolicyRecipesDesiredStateEnum) Validate 

func (v GuestPolicyRecipesDesiredStateEnum) Validate() error

type GuestPolicyRecipesInstallSteps 

type GuestPolicyRecipesInstallSteps struct {
	FileCopy          *GuestPolicyRecipesInstallStepsFileCopy          `json:"fileCopy"`
	ArchiveExtraction *GuestPolicyRecipesInstallStepsArchiveExtraction `json:"archiveExtraction"`
	MsiInstallation   *GuestPolicyRecipesInstallStepsMsiInstallation   `json:"msiInstallation"`
	DpkgInstallation  *GuestPolicyRecipesInstallStepsDpkgInstallation  `json:"dpkgInstallation"`
	RpmInstallation   *GuestPolicyRecipesInstallStepsRpmInstallation   `json:"rpmInstallation"`
	FileExec          *GuestPolicyRecipesInstallStepsFileExec          `json:"fileExec"`
	ScriptRun         *GuestPolicyRecipesInstallStepsScriptRun         `json:"scriptRun"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyRecipesInstallSteps *GuestPolicyRecipesInstallSteps = &GuestPolicyRecipesInstallSteps{empty: true}

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

func (*GuestPolicyRecipesInstallSteps) Empty 

func (r *GuestPolicyRecipesInstallSteps) Empty() bool

func (*GuestPolicyRecipesInstallSteps) HashCode 

func (r *GuestPolicyRecipesInstallSteps) HashCode() string

func (*GuestPolicyRecipesInstallSteps) String 

func (r *GuestPolicyRecipesInstallSteps) String() string

func (*GuestPolicyRecipesInstallSteps) UnmarshalJSON 

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

type GuestPolicyRecipesInstallStepsArchiveExtraction 

type GuestPolicyRecipesInstallStepsArchiveExtraction struct {
	ArtifactId  *string                                                  `json:"artifactId"`
	Destination *string                                                  `json:"destination"`
	Type        *GuestPolicyRecipesInstallStepsArchiveExtractionTypeEnum `json:"type"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyRecipesInstallStepsArchiveExtraction *GuestPolicyRecipesInstallStepsArchiveExtraction = &GuestPolicyRecipesInstallStepsArchiveExtraction{empty: true}

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

func (*GuestPolicyRecipesInstallStepsArchiveExtraction) Empty 

func (r *GuestPolicyRecipesInstallStepsArchiveExtraction) Empty() bool

func (*GuestPolicyRecipesInstallStepsArchiveExtraction) HashCode 

func (r *GuestPolicyRecipesInstallStepsArchiveExtraction) HashCode() string

func (*GuestPolicyRecipesInstallStepsArchiveExtraction) String 

func (r *GuestPolicyRecipesInstallStepsArchiveExtraction) String() string

func (*GuestPolicyRecipesInstallStepsArchiveExtraction) UnmarshalJSON 

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

type GuestPolicyRecipesInstallStepsArchiveExtractionTypeEnum 

type GuestPolicyRecipesInstallStepsArchiveExtractionTypeEnum string

The enum GuestPolicyRecipesInstallStepsArchiveExtractionTypeEnum.

func GuestPolicyRecipesInstallStepsArchiveExtractionTypeEnumRef 

func GuestPolicyRecipesInstallStepsArchiveExtractionTypeEnumRef(s string) *GuestPolicyRecipesInstallStepsArchiveExtractionTypeEnum

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

func (GuestPolicyRecipesInstallStepsArchiveExtractionTypeEnum) Validate 

func (v GuestPolicyRecipesInstallStepsArchiveExtractionTypeEnum) Validate() error

type GuestPolicyRecipesInstallStepsDpkgInstallation 

type GuestPolicyRecipesInstallStepsDpkgInstallation struct {
	ArtifactId *string `json:"artifactId"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyRecipesInstallStepsDpkgInstallation *GuestPolicyRecipesInstallStepsDpkgInstallation = &GuestPolicyRecipesInstallStepsDpkgInstallation{empty: true}

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

func (*GuestPolicyRecipesInstallStepsDpkgInstallation) Empty 

func (r *GuestPolicyRecipesInstallStepsDpkgInstallation) Empty() bool

func (*GuestPolicyRecipesInstallStepsDpkgInstallation) HashCode 

func (r *GuestPolicyRecipesInstallStepsDpkgInstallation) HashCode() string

func (*GuestPolicyRecipesInstallStepsDpkgInstallation) String 

func (r *GuestPolicyRecipesInstallStepsDpkgInstallation) String() string

func (*GuestPolicyRecipesInstallStepsDpkgInstallation) UnmarshalJSON 

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

type GuestPolicyRecipesInstallStepsFileCopy 

type GuestPolicyRecipesInstallStepsFileCopy struct {
	ArtifactId  *string `json:"artifactId"`
	Destination *string `json:"destination"`
	Overwrite   *bool   `json:"overwrite"`
	Permissions *string `json:"permissions"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyRecipesInstallStepsFileCopy *GuestPolicyRecipesInstallStepsFileCopy = &GuestPolicyRecipesInstallStepsFileCopy{empty: true}

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

func (*GuestPolicyRecipesInstallStepsFileCopy) Empty 

func (r *GuestPolicyRecipesInstallStepsFileCopy) Empty() bool

func (*GuestPolicyRecipesInstallStepsFileCopy) HashCode 

func (r *GuestPolicyRecipesInstallStepsFileCopy) HashCode() string

func (*GuestPolicyRecipesInstallStepsFileCopy) String 

func (r *GuestPolicyRecipesInstallStepsFileCopy) String() string

func (*GuestPolicyRecipesInstallStepsFileCopy) UnmarshalJSON 

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

type GuestPolicyRecipesInstallStepsFileExec 

type GuestPolicyRecipesInstallStepsFileExec struct {
	ArtifactId       *string  `json:"artifactId"`
	LocalPath        *string  `json:"localPath"`
	Args             []string `json:"args"`
	AllowedExitCodes []int64  `json:"allowedExitCodes"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyRecipesInstallStepsFileExec *GuestPolicyRecipesInstallStepsFileExec = &GuestPolicyRecipesInstallStepsFileExec{empty: true}

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

func (*GuestPolicyRecipesInstallStepsFileExec) Empty 

func (r *GuestPolicyRecipesInstallStepsFileExec) Empty() bool

func (*GuestPolicyRecipesInstallStepsFileExec) HashCode 

func (r *GuestPolicyRecipesInstallStepsFileExec) HashCode() string

func (*GuestPolicyRecipesInstallStepsFileExec) String 

func (r *GuestPolicyRecipesInstallStepsFileExec) String() string

func (*GuestPolicyRecipesInstallStepsFileExec) UnmarshalJSON 

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

type GuestPolicyRecipesInstallStepsMsiInstallation 

type GuestPolicyRecipesInstallStepsMsiInstallation struct {
	ArtifactId       *string  `json:"artifactId"`
	Flags            []string `json:"flags"`
	AllowedExitCodes []int64  `json:"allowedExitCodes"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyRecipesInstallStepsMsiInstallation *GuestPolicyRecipesInstallStepsMsiInstallation = &GuestPolicyRecipesInstallStepsMsiInstallation{empty: true}

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

func (*GuestPolicyRecipesInstallStepsMsiInstallation) Empty 

func (r *GuestPolicyRecipesInstallStepsMsiInstallation) Empty() bool

func (*GuestPolicyRecipesInstallStepsMsiInstallation) HashCode 

func (r *GuestPolicyRecipesInstallStepsMsiInstallation) HashCode() string

func (*GuestPolicyRecipesInstallStepsMsiInstallation) String 

func (r *GuestPolicyRecipesInstallStepsMsiInstallation) String() string

func (*GuestPolicyRecipesInstallStepsMsiInstallation) UnmarshalJSON 

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

type GuestPolicyRecipesInstallStepsRpmInstallation 

type GuestPolicyRecipesInstallStepsRpmInstallation struct {
	ArtifactId *string `json:"artifactId"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyRecipesInstallStepsRpmInstallation *GuestPolicyRecipesInstallStepsRpmInstallation = &GuestPolicyRecipesInstallStepsRpmInstallation{empty: true}

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

func (*GuestPolicyRecipesInstallStepsRpmInstallation) Empty 

func (r *GuestPolicyRecipesInstallStepsRpmInstallation) Empty() bool

func (*GuestPolicyRecipesInstallStepsRpmInstallation) HashCode 

func (r *GuestPolicyRecipesInstallStepsRpmInstallation) HashCode() string

func (*GuestPolicyRecipesInstallStepsRpmInstallation) String 

func (r *GuestPolicyRecipesInstallStepsRpmInstallation) String() string

func (*GuestPolicyRecipesInstallStepsRpmInstallation) UnmarshalJSON 

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

type GuestPolicyRecipesInstallStepsScriptRun 

type GuestPolicyRecipesInstallStepsScriptRun struct {
	Script           *string                                                 `json:"script"`
	AllowedExitCodes []int64                                                 `json:"allowedExitCodes"`
	Interpreter      *GuestPolicyRecipesInstallStepsScriptRunInterpreterEnum `json:"interpreter"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyRecipesInstallStepsScriptRun *GuestPolicyRecipesInstallStepsScriptRun = &GuestPolicyRecipesInstallStepsScriptRun{empty: true}

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

func (*GuestPolicyRecipesInstallStepsScriptRun) Empty 

func (r *GuestPolicyRecipesInstallStepsScriptRun) Empty() bool

func (*GuestPolicyRecipesInstallStepsScriptRun) HashCode 

func (r *GuestPolicyRecipesInstallStepsScriptRun) HashCode() string

func (*GuestPolicyRecipesInstallStepsScriptRun) String 

func (r *GuestPolicyRecipesInstallStepsScriptRun) String() string

func (*GuestPolicyRecipesInstallStepsScriptRun) UnmarshalJSON 

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

type GuestPolicyRecipesInstallStepsScriptRunInterpreterEnum 

type GuestPolicyRecipesInstallStepsScriptRunInterpreterEnum string

The enum GuestPolicyRecipesInstallStepsScriptRunInterpreterEnum.

func GuestPolicyRecipesInstallStepsScriptRunInterpreterEnumRef 

func GuestPolicyRecipesInstallStepsScriptRunInterpreterEnumRef(s string) *GuestPolicyRecipesInstallStepsScriptRunInterpreterEnum

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

func (GuestPolicyRecipesInstallStepsScriptRunInterpreterEnum) Validate 

func (v GuestPolicyRecipesInstallStepsScriptRunInterpreterEnum) Validate() error

type GuestPolicyRecipesUpdateSteps 

type GuestPolicyRecipesUpdateSteps struct {
	FileCopy          *GuestPolicyRecipesUpdateStepsFileCopy          `json:"fileCopy"`
	ArchiveExtraction *GuestPolicyRecipesUpdateStepsArchiveExtraction `json:"archiveExtraction"`
	MsiInstallation   *GuestPolicyRecipesUpdateStepsMsiInstallation   `json:"msiInstallation"`
	DpkgInstallation  *GuestPolicyRecipesUpdateStepsDpkgInstallation  `json:"dpkgInstallation"`
	RpmInstallation   *GuestPolicyRecipesUpdateStepsRpmInstallation   `json:"rpmInstallation"`
	FileExec          *GuestPolicyRecipesUpdateStepsFileExec          `json:"fileExec"`
	ScriptRun         *GuestPolicyRecipesUpdateStepsScriptRun         `json:"scriptRun"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyRecipesUpdateSteps *GuestPolicyRecipesUpdateSteps = &GuestPolicyRecipesUpdateSteps{empty: true}

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

func (*GuestPolicyRecipesUpdateSteps) Empty 

func (r *GuestPolicyRecipesUpdateSteps) Empty() bool

func (*GuestPolicyRecipesUpdateSteps) HashCode 

func (r *GuestPolicyRecipesUpdateSteps) HashCode() string

func (*GuestPolicyRecipesUpdateSteps) String 

func (r *GuestPolicyRecipesUpdateSteps) String() string

func (*GuestPolicyRecipesUpdateSteps) UnmarshalJSON 

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

type GuestPolicyRecipesUpdateStepsArchiveExtraction 

type GuestPolicyRecipesUpdateStepsArchiveExtraction struct {
	ArtifactId  *string                                                 `json:"artifactId"`
	Destination *string                                                 `json:"destination"`
	Type        *GuestPolicyRecipesUpdateStepsArchiveExtractionTypeEnum `json:"type"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyRecipesUpdateStepsArchiveExtraction *GuestPolicyRecipesUpdateStepsArchiveExtraction = &GuestPolicyRecipesUpdateStepsArchiveExtraction{empty: true}

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

func (*GuestPolicyRecipesUpdateStepsArchiveExtraction) Empty 

func (r *GuestPolicyRecipesUpdateStepsArchiveExtraction) Empty() bool

func (*GuestPolicyRecipesUpdateStepsArchiveExtraction) HashCode 

func (r *GuestPolicyRecipesUpdateStepsArchiveExtraction) HashCode() string

func (*GuestPolicyRecipesUpdateStepsArchiveExtraction) String 

func (r *GuestPolicyRecipesUpdateStepsArchiveExtraction) String() string

func (*GuestPolicyRecipesUpdateStepsArchiveExtraction) UnmarshalJSON 

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

type GuestPolicyRecipesUpdateStepsArchiveExtractionTypeEnum 

type GuestPolicyRecipesUpdateStepsArchiveExtractionTypeEnum string

The enum GuestPolicyRecipesUpdateStepsArchiveExtractionTypeEnum.

func GuestPolicyRecipesUpdateStepsArchiveExtractionTypeEnumRef 

func GuestPolicyRecipesUpdateStepsArchiveExtractionTypeEnumRef(s string) *GuestPolicyRecipesUpdateStepsArchiveExtractionTypeEnum

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

func (GuestPolicyRecipesUpdateStepsArchiveExtractionTypeEnum) Validate 

func (v GuestPolicyRecipesUpdateStepsArchiveExtractionTypeEnum) Validate() error

type GuestPolicyRecipesUpdateStepsDpkgInstallation 

type GuestPolicyRecipesUpdateStepsDpkgInstallation struct {
	ArtifactId *string `json:"artifactId"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyRecipesUpdateStepsDpkgInstallation *GuestPolicyRecipesUpdateStepsDpkgInstallation = &GuestPolicyRecipesUpdateStepsDpkgInstallation{empty: true}

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

func (*GuestPolicyRecipesUpdateStepsDpkgInstallation) Empty 

func (r *GuestPolicyRecipesUpdateStepsDpkgInstallation) Empty() bool

func (*GuestPolicyRecipesUpdateStepsDpkgInstallation) HashCode 

func (r *GuestPolicyRecipesUpdateStepsDpkgInstallation) HashCode() string

func (*GuestPolicyRecipesUpdateStepsDpkgInstallation) String 

func (r *GuestPolicyRecipesUpdateStepsDpkgInstallation) String() string

func (*GuestPolicyRecipesUpdateStepsDpkgInstallation) UnmarshalJSON 

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

type GuestPolicyRecipesUpdateStepsFileCopy 

type GuestPolicyRecipesUpdateStepsFileCopy struct {
	ArtifactId  *string `json:"artifactId"`
	Destination *string `json:"destination"`
	Overwrite   *bool   `json:"overwrite"`
	Permissions *string `json:"permissions"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyRecipesUpdateStepsFileCopy *GuestPolicyRecipesUpdateStepsFileCopy = &GuestPolicyRecipesUpdateStepsFileCopy{empty: true}

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

func (*GuestPolicyRecipesUpdateStepsFileCopy) Empty 

func (r *GuestPolicyRecipesUpdateStepsFileCopy) Empty() bool

func (*GuestPolicyRecipesUpdateStepsFileCopy) HashCode 

func (r *GuestPolicyRecipesUpdateStepsFileCopy) HashCode() string

func (*GuestPolicyRecipesUpdateStepsFileCopy) String 

func (r *GuestPolicyRecipesUpdateStepsFileCopy) String() string

func (*GuestPolicyRecipesUpdateStepsFileCopy) UnmarshalJSON 

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

type GuestPolicyRecipesUpdateStepsFileExec 

type GuestPolicyRecipesUpdateStepsFileExec struct {
	ArtifactId       *string  `json:"artifactId"`
	LocalPath        *string  `json:"localPath"`
	Args             []string `json:"args"`
	AllowedExitCodes []int64  `json:"allowedExitCodes"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyRecipesUpdateStepsFileExec *GuestPolicyRecipesUpdateStepsFileExec = &GuestPolicyRecipesUpdateStepsFileExec{empty: true}

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

func (*GuestPolicyRecipesUpdateStepsFileExec) Empty 

func (r *GuestPolicyRecipesUpdateStepsFileExec) Empty() bool

func (*GuestPolicyRecipesUpdateStepsFileExec) HashCode 

func (r *GuestPolicyRecipesUpdateStepsFileExec) HashCode() string

func (*GuestPolicyRecipesUpdateStepsFileExec) String 

func (r *GuestPolicyRecipesUpdateStepsFileExec) String() string

func (*GuestPolicyRecipesUpdateStepsFileExec) UnmarshalJSON 

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

type GuestPolicyRecipesUpdateStepsMsiInstallation 

type GuestPolicyRecipesUpdateStepsMsiInstallation struct {
	ArtifactId       *string  `json:"artifactId"`
	Flags            []string `json:"flags"`
	AllowedExitCodes []int64  `json:"allowedExitCodes"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyRecipesUpdateStepsMsiInstallation *GuestPolicyRecipesUpdateStepsMsiInstallation = &GuestPolicyRecipesUpdateStepsMsiInstallation{empty: true}

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

func (*GuestPolicyRecipesUpdateStepsMsiInstallation) Empty 

func (r *GuestPolicyRecipesUpdateStepsMsiInstallation) Empty() bool

func (*GuestPolicyRecipesUpdateStepsMsiInstallation) HashCode 

func (r *GuestPolicyRecipesUpdateStepsMsiInstallation) HashCode() string

func (*GuestPolicyRecipesUpdateStepsMsiInstallation) String 

func (r *GuestPolicyRecipesUpdateStepsMsiInstallation) String() string

func (*GuestPolicyRecipesUpdateStepsMsiInstallation) UnmarshalJSON 

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

type GuestPolicyRecipesUpdateStepsRpmInstallation 

type GuestPolicyRecipesUpdateStepsRpmInstallation struct {
	ArtifactId *string `json:"artifactId"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyRecipesUpdateStepsRpmInstallation *GuestPolicyRecipesUpdateStepsRpmInstallation = &GuestPolicyRecipesUpdateStepsRpmInstallation{empty: true}

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

func (*GuestPolicyRecipesUpdateStepsRpmInstallation) Empty 

func (r *GuestPolicyRecipesUpdateStepsRpmInstallation) Empty() bool

func (*GuestPolicyRecipesUpdateStepsRpmInstallation) HashCode 

func (r *GuestPolicyRecipesUpdateStepsRpmInstallation) HashCode() string

func (*GuestPolicyRecipesUpdateStepsRpmInstallation) String 

func (r *GuestPolicyRecipesUpdateStepsRpmInstallation) String() string

func (*GuestPolicyRecipesUpdateStepsRpmInstallation) UnmarshalJSON 

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

type GuestPolicyRecipesUpdateStepsScriptRun 

type GuestPolicyRecipesUpdateStepsScriptRun struct {
	Script           *string                                                `json:"script"`
	AllowedExitCodes []int64                                                `json:"allowedExitCodes"`
	Interpreter      *GuestPolicyRecipesUpdateStepsScriptRunInterpreterEnum `json:"interpreter"`
	// contains filtered or unexported fields
}
var EmptyGuestPolicyRecipesUpdateStepsScriptRun *GuestPolicyRecipesUpdateStepsScriptRun = &GuestPolicyRecipesUpdateStepsScriptRun{empty: true}

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

func (*GuestPolicyRecipesUpdateStepsScriptRun) Empty 

func (r *GuestPolicyRecipesUpdateStepsScriptRun) Empty() bool

func (*GuestPolicyRecipesUpdateStepsScriptRun) HashCode 

func (r *GuestPolicyRecipesUpdateStepsScriptRun) HashCode() string

func (*GuestPolicyRecipesUpdateStepsScriptRun) String 

func (r *GuestPolicyRecipesUpdateStepsScriptRun) String() string

func (*GuestPolicyRecipesUpdateStepsScriptRun) UnmarshalJSON 

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

type GuestPolicyRecipesUpdateStepsScriptRunInterpreterEnum 

type GuestPolicyRecipesUpdateStepsScriptRunInterpreterEnum string

The enum GuestPolicyRecipesUpdateStepsScriptRunInterpreterEnum.

func GuestPolicyRecipesUpdateStepsScriptRunInterpreterEnumRef 

func GuestPolicyRecipesUpdateStepsScriptRunInterpreterEnumRef(s string) *GuestPolicyRecipesUpdateStepsScriptRunInterpreterEnum

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

func (GuestPolicyRecipesUpdateStepsScriptRunInterpreterEnum) Validate 

func (v GuestPolicyRecipesUpdateStepsScriptRunInterpreterEnum) Validate() error

type OSPolicyAssignment 

type OSPolicyAssignment struct {
	Name               *string                             `json:"name"`
	Description        *string                             `json:"description"`
	OSPolicies         []OSPolicyAssignmentOSPolicies      `json:"osPolicies"`
	InstanceFilter     *OSPolicyAssignmentInstanceFilter   `json:"instanceFilter"`
	Rollout            *OSPolicyAssignmentRollout          `json:"rollout"`
	RevisionId         *string                             `json:"revisionId"`
	RevisionCreateTime *string                             `json:"revisionCreateTime"`
	Etag               *string                             `json:"etag"`
	RolloutState       *OSPolicyAssignmentRolloutStateEnum `json:"rolloutState"`
	Baseline           *bool                               `json:"baseline"`
	Deleted            *bool                               `json:"deleted"`
	Reconciling        *bool                               `json:"reconciling"`
	Uid                *string                             `json:"uid"`
	Project            *string                             `json:"project"`
	Location           *string                             `json:"location"`
	SkipAwaitRollout   *bool                               `json:"skipAwaitRollout"`
}

func (*OSPolicyAssignment) Describe 

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

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

func (*OSPolicyAssignment) ID 

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

func (*OSPolicyAssignment) String 

func (r *OSPolicyAssignment) String() string

type OSPolicyAssignmentInstanceFilter 

type OSPolicyAssignmentInstanceFilter struct {
	All             *bool                                             `json:"all"`
	InclusionLabels []OSPolicyAssignmentInstanceFilterInclusionLabels `json:"inclusionLabels"`
	ExclusionLabels []OSPolicyAssignmentInstanceFilterExclusionLabels `json:"exclusionLabels"`
	Inventories     []OSPolicyAssignmentInstanceFilterInventories     `json:"inventories"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentInstanceFilter *OSPolicyAssignmentInstanceFilter = &OSPolicyAssignmentInstanceFilter{empty: true}

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

func (*OSPolicyAssignmentInstanceFilter) Empty 

func (r *OSPolicyAssignmentInstanceFilter) Empty() bool

func (*OSPolicyAssignmentInstanceFilter) HashCode 

func (r *OSPolicyAssignmentInstanceFilter) HashCode() string

func (*OSPolicyAssignmentInstanceFilter) String 

func (r *OSPolicyAssignmentInstanceFilter) String() string

func (*OSPolicyAssignmentInstanceFilter) UnmarshalJSON 

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

type OSPolicyAssignmentInstanceFilterExclusionLabels 

type OSPolicyAssignmentInstanceFilterExclusionLabels struct {
	Labels map[string]string `json:"labels"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentInstanceFilterExclusionLabels *OSPolicyAssignmentInstanceFilterExclusionLabels = &OSPolicyAssignmentInstanceFilterExclusionLabels{empty: true}

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

func (*OSPolicyAssignmentInstanceFilterExclusionLabels) Empty 

func (r *OSPolicyAssignmentInstanceFilterExclusionLabels) Empty() bool

func (*OSPolicyAssignmentInstanceFilterExclusionLabels) HashCode 

func (r *OSPolicyAssignmentInstanceFilterExclusionLabels) HashCode() string

func (*OSPolicyAssignmentInstanceFilterExclusionLabels) String 

func (r *OSPolicyAssignmentInstanceFilterExclusionLabels) String() string

func (*OSPolicyAssignmentInstanceFilterExclusionLabels) UnmarshalJSON 

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

type OSPolicyAssignmentInstanceFilterInclusionLabels 

type OSPolicyAssignmentInstanceFilterInclusionLabels struct {
	Labels map[string]string `json:"labels"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentInstanceFilterInclusionLabels *OSPolicyAssignmentInstanceFilterInclusionLabels = &OSPolicyAssignmentInstanceFilterInclusionLabels{empty: true}

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

func (*OSPolicyAssignmentInstanceFilterInclusionLabels) Empty 

func (r *OSPolicyAssignmentInstanceFilterInclusionLabels) Empty() bool

func (*OSPolicyAssignmentInstanceFilterInclusionLabels) HashCode 

func (r *OSPolicyAssignmentInstanceFilterInclusionLabels) HashCode() string

func (*OSPolicyAssignmentInstanceFilterInclusionLabels) String 

func (r *OSPolicyAssignmentInstanceFilterInclusionLabels) String() string

func (*OSPolicyAssignmentInstanceFilterInclusionLabels) UnmarshalJSON 

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

type OSPolicyAssignmentInstanceFilterInventories 

type OSPolicyAssignmentInstanceFilterInventories struct {
	OSShortName *string `json:"osShortName"`
	OSVersion   *string `json:"osVersion"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentInstanceFilterInventories *OSPolicyAssignmentInstanceFilterInventories = &OSPolicyAssignmentInstanceFilterInventories{empty: true}

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

func (*OSPolicyAssignmentInstanceFilterInventories) Empty 

func (r *OSPolicyAssignmentInstanceFilterInventories) Empty() bool

func (*OSPolicyAssignmentInstanceFilterInventories) HashCode 

func (r *OSPolicyAssignmentInstanceFilterInventories) HashCode() string

func (*OSPolicyAssignmentInstanceFilterInventories) String 

func (r *OSPolicyAssignmentInstanceFilterInventories) String() string

func (*OSPolicyAssignmentInstanceFilterInventories) UnmarshalJSON 

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

type OSPolicyAssignmentList 

type OSPolicyAssignmentList struct {
	Items []*OSPolicyAssignment
	// contains filtered or unexported fields
}

func (*OSPolicyAssignmentList) HasNext 

func (l *OSPolicyAssignmentList) HasNext() bool

func (*OSPolicyAssignmentList) Next 

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

type OSPolicyAssignmentOSPolicies 

type OSPolicyAssignmentOSPolicies struct {
	Id                        *string                                      `json:"id"`
	Description               *string                                      `json:"description"`
	Mode                      *OSPolicyAssignmentOSPoliciesModeEnum        `json:"mode"`
	ResourceGroups            []OSPolicyAssignmentOSPoliciesResourceGroups `json:"resourceGroups"`
	AllowNoResourceGroupMatch *bool                                        `json:"allowNoResourceGroupMatch"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPolicies *OSPolicyAssignmentOSPolicies = &OSPolicyAssignmentOSPolicies{empty: true}

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

func (*OSPolicyAssignmentOSPolicies) Empty 

func (r *OSPolicyAssignmentOSPolicies) Empty() bool

func (*OSPolicyAssignmentOSPolicies) HashCode 

func (r *OSPolicyAssignmentOSPolicies) HashCode() string

func (*OSPolicyAssignmentOSPolicies) String 

func (r *OSPolicyAssignmentOSPolicies) String() string

func (*OSPolicyAssignmentOSPolicies) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesModeEnum 

type OSPolicyAssignmentOSPoliciesModeEnum string

The enum OSPolicyAssignmentOSPoliciesModeEnum.

func OSPolicyAssignmentOSPoliciesModeEnumRef 

func OSPolicyAssignmentOSPoliciesModeEnumRef(s string) *OSPolicyAssignmentOSPoliciesModeEnum

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

func (OSPolicyAssignmentOSPoliciesModeEnum) Validate 

func (v OSPolicyAssignmentOSPoliciesModeEnum) Validate() error

type OSPolicyAssignmentOSPoliciesResourceGroups 

type OSPolicyAssignmentOSPoliciesResourceGroups struct {
	InventoryFilters []OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters `json:"inventoryFilters"`
	Resources        []OSPolicyAssignmentOSPoliciesResourceGroupsResources        `json:"resources"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroups *OSPolicyAssignmentOSPoliciesResourceGroups = &OSPolicyAssignmentOSPoliciesResourceGroups{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroups) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroups) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroups) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroups) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroups) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroups) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroups) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters 

type OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters struct {
	OSShortName *string `json:"osShortName"`
	OSVersion   *string `json:"osVersion"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters *OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters = &OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsInventoryFilters) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResources 

type OSPolicyAssignmentOSPoliciesResourceGroupsResources struct {
	Id         *string                                                        `json:"id"`
	Pkg        *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg        `json:"pkg"`
	Repository *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository `json:"repository"`
	Exec       *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec       `json:"exec"`
	File       *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile       `json:"file"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResources *OSPolicyAssignmentOSPoliciesResourceGroupsResources = &OSPolicyAssignmentOSPoliciesResourceGroupsResources{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResources) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResources) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResources) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResources) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResources) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResources) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResources) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec struct {
	Validate *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate `json:"validate"`
	Enforce  *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce  `json:"enforce"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExec) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce struct {
	File           *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile            `json:"file"`
	Script         *string                                                                        `json:"script"`
	Args           []string                                                                       `json:"args"`
	Interpreter    *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnum `json:"interpreter"`
	OutputFilePath *string                                                                        `json:"outputFilePath"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforce) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile struct {
	Remote        *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote `json:"remote"`
	Gcs           *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs    `json:"gcs"`
	LocalPath     *string                                                                   `json:"localPath"`
	AllowInsecure *bool                                                                     `json:"allowInsecure"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFile) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs struct {
	Bucket     *string `json:"bucket"`
	Object     *string `json:"object"`
	Generation *int64  `json:"generation"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileGcs) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote struct {
	Uri            *string `json:"uri"`
	Sha256Checksum *string `json:"sha256Checksum"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceFileRemote) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnum 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnum string

The enum OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnum.

func OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnumRef 

func OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnumRef(s string) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnum

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

func (OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnum) Validate 

func (v OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecEnforceInterpreterEnum) Validate() error

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate struct {
	File           *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile            `json:"file"`
	Script         *string                                                                         `json:"script"`
	Args           []string                                                                        `json:"args"`
	Interpreter    *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnum `json:"interpreter"`
	OutputFilePath *string                                                                         `json:"outputFilePath"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidate) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile struct {
	Remote        *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote `json:"remote"`
	Gcs           *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs    `json:"gcs"`
	LocalPath     *string                                                                    `json:"localPath"`
	AllowInsecure *bool                                                                      `json:"allowInsecure"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFile) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs struct {
	Bucket     *string `json:"bucket"`
	Object     *string `json:"object"`
	Generation *int64  `json:"generation"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileGcs) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote struct {
	Uri            *string `json:"uri"`
	Sha256Checksum *string `json:"sha256Checksum"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateFileRemote) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnum 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnum string

The enum OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnum.

func OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnumRef 

func OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnumRef(s string) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnum

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

func (OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnum) Validate 

func (v OSPolicyAssignmentOSPoliciesResourceGroupsResourcesExecValidateInterpreterEnum) Validate() error

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile struct {
	File        *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile      `json:"file"`
	Content     *string                                                           `json:"content"`
	Path        *string                                                           `json:"path"`
	State       *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnum `json:"state"`
	Permissions *string                                                           `json:"permissions"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFile) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile struct {
	Remote        *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote `json:"remote"`
	Gcs           *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs    `json:"gcs"`
	LocalPath     *string                                                            `json:"localPath"`
	AllowInsecure *bool                                                              `json:"allowInsecure"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFile) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs struct {
	Bucket     *string `json:"bucket"`
	Object     *string `json:"object"`
	Generation *int64  `json:"generation"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileGcs) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote struct {
	Uri            *string `json:"uri"`
	Sha256Checksum *string `json:"sha256Checksum"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileFileRemote) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnum 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnum string

The enum OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnum.

func OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnumRef 

func OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnumRef(s string) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnum

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

func (OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnum) Validate 

func (v OSPolicyAssignmentOSPoliciesResourceGroupsResourcesFileStateEnum) Validate() error

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg struct {
	DesiredState *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnum `json:"desiredState"`
	Apt          *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt              `json:"apt"`
	Deb          *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb              `json:"deb"`
	Yum          *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum              `json:"yum"`
	Zypper       *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper           `json:"zypper"`
	Rpm          *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm              `json:"rpm"`
	Googet       *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget           `json:"googet"`
	Msi          *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi              `json:"msi"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkg) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt struct {
	Name *string `json:"name"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgApt) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb struct {
	Source   *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource `json:"source"`
	PullDeps *bool                                                            `json:"pullDeps"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDeb) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource struct {
	Remote        *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote `json:"remote"`
	Gcs           *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs    `json:"gcs"`
	LocalPath     *string                                                                `json:"localPath"`
	AllowInsecure *bool                                                                  `json:"allowInsecure"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSource) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs struct {
	Bucket     *string `json:"bucket"`
	Object     *string `json:"object"`
	Generation *int64  `json:"generation"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceGcs) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote struct {
	Uri            *string `json:"uri"`
	Sha256Checksum *string `json:"sha256Checksum"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDebSourceRemote) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnum 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnum string

The enum OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnum.

func OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnumRef 

func OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnumRef(s string) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnum

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

func (OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnum) Validate 

func (v OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgDesiredStateEnum) Validate() error

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget struct {
	Name *string `json:"name"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgGooget) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi struct {
	Source     *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource `json:"source"`
	Properties []string                                                         `json:"properties"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsi) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource struct {
	Remote        *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote `json:"remote"`
	Gcs           *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs    `json:"gcs"`
	LocalPath     *string                                                                `json:"localPath"`
	AllowInsecure *bool                                                                  `json:"allowInsecure"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSource) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs struct {
	Bucket     *string `json:"bucket"`
	Object     *string `json:"object"`
	Generation *int64  `json:"generation"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceGcs) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote struct {
	Uri            *string `json:"uri"`
	Sha256Checksum *string `json:"sha256Checksum"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgMsiSourceRemote) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm struct {
	Source   *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource `json:"source"`
	PullDeps *bool                                                            `json:"pullDeps"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpm) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource struct {
	Remote        *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote `json:"remote"`
	Gcs           *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs    `json:"gcs"`
	LocalPath     *string                                                                `json:"localPath"`
	AllowInsecure *bool                                                                  `json:"allowInsecure"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSource) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs struct {
	Bucket     *string `json:"bucket"`
	Object     *string `json:"object"`
	Generation *int64  `json:"generation"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceGcs) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote struct {
	Uri            *string `json:"uri"`
	Sha256Checksum *string `json:"sha256Checksum"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgRpmSourceRemote) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum struct {
	Name *string `json:"name"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgYum) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper struct {
	Name *string `json:"name"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesPkgZypper) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository struct {
	Apt    *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt    `json:"apt"`
	Yum    *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum    `json:"yum"`
	Zypper *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper `json:"zypper"`
	Goo    *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo    `json:"goo"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepository) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt struct {
	ArchiveType  *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnum `json:"archiveType"`
	Uri          *string                                                                          `json:"uri"`
	Distribution *string                                                                          `json:"distribution"`
	Components   []string                                                                         `json:"components"`
	GpgKey       *string                                                                          `json:"gpgKey"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryApt) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnum 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnum string

The enum OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnum.

func OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnumRef 

func OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnumRef(s string) *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnum

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

func (OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnum) Validate 

func (v OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryAptArchiveTypeEnum) Validate() error

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo struct {
	Name *string `json:"name"`
	Url  *string `json:"url"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryGoo) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum struct {
	Id          *string  `json:"id"`
	DisplayName *string  `json:"displayName"`
	BaseUrl     *string  `json:"baseUrl"`
	GpgKeys     []string `json:"gpgKeys"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryYum) UnmarshalJSON 

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

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper 

type OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper struct {
	Id          *string  `json:"id"`
	DisplayName *string  `json:"displayName"`
	BaseUrl     *string  `json:"baseUrl"`
	GpgKeys     []string `json:"gpgKeys"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper = &OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper{empty: true}

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

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper) Empty 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper) Empty() bool

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper) HashCode 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper) HashCode() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper) String 

func (r *OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper) String() string

func (*OSPolicyAssignmentOSPoliciesResourceGroupsResourcesRepositoryZypper) UnmarshalJSON 

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

type OSPolicyAssignmentRollout 

type OSPolicyAssignmentRollout struct {
	DisruptionBudget *OSPolicyAssignmentRolloutDisruptionBudget `json:"disruptionBudget"`
	MinWaitDuration  *string                                    `json:"minWaitDuration"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentRollout *OSPolicyAssignmentRollout = &OSPolicyAssignmentRollout{empty: true}

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

func (*OSPolicyAssignmentRollout) Empty 

func (r *OSPolicyAssignmentRollout) Empty() bool

func (*OSPolicyAssignmentRollout) HashCode 

func (r *OSPolicyAssignmentRollout) HashCode() string

func (*OSPolicyAssignmentRollout) String 

func (r *OSPolicyAssignmentRollout) String() string

func (*OSPolicyAssignmentRollout) UnmarshalJSON 

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

type OSPolicyAssignmentRolloutDisruptionBudget 

type OSPolicyAssignmentRolloutDisruptionBudget struct {
	Fixed   *int64 `json:"fixed"`
	Percent *int64 `json:"percent"`
	// contains filtered or unexported fields
}
var EmptyOSPolicyAssignmentRolloutDisruptionBudget *OSPolicyAssignmentRolloutDisruptionBudget = &OSPolicyAssignmentRolloutDisruptionBudget{empty: true}

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

func (*OSPolicyAssignmentRolloutDisruptionBudget) Empty 

func (r *OSPolicyAssignmentRolloutDisruptionBudget) Empty() bool

func (*OSPolicyAssignmentRolloutDisruptionBudget) HashCode 

func (r *OSPolicyAssignmentRolloutDisruptionBudget) HashCode() string

func (*OSPolicyAssignmentRolloutDisruptionBudget) String 

func (r *OSPolicyAssignmentRolloutDisruptionBudget) String() string

func (*OSPolicyAssignmentRolloutDisruptionBudget) UnmarshalJSON 

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

type OSPolicyAssignmentRolloutStateEnum 

type OSPolicyAssignmentRolloutStateEnum string

The enum OSPolicyAssignmentRolloutStateEnum.

func OSPolicyAssignmentRolloutStateEnumRef 

func OSPolicyAssignmentRolloutStateEnumRef(s string) *OSPolicyAssignmentRolloutStateEnum

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

func (OSPolicyAssignmentRolloutStateEnum) Validate 

func (v OSPolicyAssignmentRolloutStateEnum) Validate() 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.