github.com/tilt-dev/tilt@v0.33.15-0.20240515162809-0a22ed45d8a0/internal/tiltfile/v1alpha1/types.go (about)

     1  package v1alpha1
     2  
     3  import (
     4  	"fmt"
     5  	"time"
     6  
     7  	"go.starlark.net/starlark"
     8  	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
     9  
    10  	"github.com/tilt-dev/tilt/internal/tiltfile/starkit"
    11  	"github.com/tilt-dev/tilt/internal/tiltfile/value"
    12  	"github.com/tilt-dev/tilt/pkg/apis/core/v1alpha1"
    13  )
    14  
    15  // AUTOGENERATED by github.com/tilt-dev/tilt-starlark-codegen
    16  // DO NOT EDIT MANUALLY
    17  
    18  func (p Plugin) registerSymbols(env *starkit.Environment) error {
    19  	var err error
    20  
    21  	err = env.AddBuiltin("v1alpha1.cmd", p.cmd)
    22  	if err != nil {
    23  		return err
    24  	}
    25  	err = env.AddBuiltin("v1alpha1.config_map", p.configMap)
    26  	if err != nil {
    27  		return err
    28  	}
    29  	err = env.AddBuiltin("v1alpha1.extension", p.extension)
    30  	if err != nil {
    31  		return err
    32  	}
    33  	err = env.AddBuiltin("v1alpha1.extension_repo", p.extensionRepo)
    34  	if err != nil {
    35  		return err
    36  	}
    37  	err = env.AddBuiltin("v1alpha1.file_watch", p.fileWatch)
    38  	if err != nil {
    39  		return err
    40  	}
    41  	err = env.AddBuiltin("v1alpha1.kubernetes_apply", p.kubernetesApply)
    42  	if err != nil {
    43  		return err
    44  	}
    45  	err = env.AddBuiltin("v1alpha1.kubernetes_discovery", p.kubernetesDiscovery)
    46  	if err != nil {
    47  		return err
    48  	}
    49  	err = env.AddBuiltin("v1alpha1.ui_button", p.uiButton)
    50  	if err != nil {
    51  		return err
    52  	}
    53  	err = env.AddBuiltin("v1alpha1.config_map_disable_source", p.configMapDisableSource)
    54  	if err != nil {
    55  		return err
    56  	}
    57  	err = env.AddBuiltin("v1alpha1.disable_source", p.disableSource)
    58  	if err != nil {
    59  		return err
    60  	}
    61  	err = env.AddBuiltin("v1alpha1.exec_action", p.execAction)
    62  	if err != nil {
    63  		return err
    64  	}
    65  	err = env.AddBuiltin("v1alpha1.forward", p.forward)
    66  	if err != nil {
    67  		return err
    68  	}
    69  	err = env.AddBuiltin("v1alpha1.http_get_action", p.hTTPGetAction)
    70  	if err != nil {
    71  		return err
    72  	}
    73  	err = env.AddBuiltin("v1alpha1.http_header", p.hTTPHeader)
    74  	if err != nil {
    75  		return err
    76  	}
    77  	err = env.AddBuiltin("v1alpha1.handler", p.handler)
    78  	if err != nil {
    79  		return err
    80  	}
    81  	err = env.AddBuiltin("v1alpha1.ignore_def", p.ignoreDef)
    82  	if err != nil {
    83  		return err
    84  	}
    85  	err = env.AddBuiltin("v1alpha1.kubernetes_apply_cmd", p.kubernetesApplyCmd)
    86  	if err != nil {
    87  		return err
    88  	}
    89  	err = env.AddBuiltin("v1alpha1.kubernetes_discovery_template_spec", p.kubernetesDiscoveryTemplateSpec)
    90  	if err != nil {
    91  		return err
    92  	}
    93  	err = env.AddBuiltin("v1alpha1.kubernetes_image_locator", p.kubernetesImageLocator)
    94  	if err != nil {
    95  		return err
    96  	}
    97  	err = env.AddBuiltin("v1alpha1.kubernetes_image_object_descriptor", p.kubernetesImageObjectDescriptor)
    98  	if err != nil {
    99  		return err
   100  	}
   101  	err = env.AddBuiltin("v1alpha1.kubernetes_watch_ref", p.kubernetesWatchRef)
   102  	if err != nil {
   103  		return err
   104  	}
   105  	err = env.AddBuiltin("v1alpha1.label_selector", p.labelSelector)
   106  	if err != nil {
   107  		return err
   108  	}
   109  	err = env.AddBuiltin("v1alpha1.label_selector_requirement", p.labelSelectorRequirement)
   110  	if err != nil {
   111  		return err
   112  	}
   113  	err = env.AddBuiltin("v1alpha1.object_selector", p.objectSelector)
   114  	if err != nil {
   115  		return err
   116  	}
   117  	err = env.AddBuiltin("v1alpha1.pod_log_stream_template_spec", p.podLogStreamTemplateSpec)
   118  	if err != nil {
   119  		return err
   120  	}
   121  	err = env.AddBuiltin("v1alpha1.port_forward_template_spec", p.portForwardTemplateSpec)
   122  	if err != nil {
   123  		return err
   124  	}
   125  	err = env.AddBuiltin("v1alpha1.probe", p.probe)
   126  	if err != nil {
   127  		return err
   128  	}
   129  	err = env.AddBuiltin("v1alpha1.restart_on_spec", p.restartOnSpec)
   130  	if err != nil {
   131  		return err
   132  	}
   133  	err = env.AddBuiltin("v1alpha1.start_on_spec", p.startOnSpec)
   134  	if err != nil {
   135  		return err
   136  	}
   137  	err = env.AddBuiltin("v1alpha1.tcp_socket_action", p.tCPSocketAction)
   138  	if err != nil {
   139  		return err
   140  	}
   141  	err = env.AddBuiltin("v1alpha1.ui_bool_input_spec", p.uIBoolInputSpec)
   142  	if err != nil {
   143  		return err
   144  	}
   145  	err = env.AddBuiltin("v1alpha1.ui_choice_input_spec", p.uIChoiceInputSpec)
   146  	if err != nil {
   147  		return err
   148  	}
   149  	err = env.AddBuiltin("v1alpha1.ui_component_location", p.uIComponentLocation)
   150  	if err != nil {
   151  		return err
   152  	}
   153  	err = env.AddBuiltin("v1alpha1.ui_hidden_input_spec", p.uIHiddenInputSpec)
   154  	if err != nil {
   155  		return err
   156  	}
   157  	err = env.AddBuiltin("v1alpha1.ui_input_spec", p.uIInputSpec)
   158  	if err != nil {
   159  		return err
   160  	}
   161  	err = env.AddBuiltin("v1alpha1.ui_text_input_spec", p.uITextInputSpec)
   162  	if err != nil {
   163  		return err
   164  	}
   165  	return nil
   166  }
   167  func (p Plugin) cmd(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   168  	var err error
   169  	obj := &v1alpha1.Cmd{
   170  		ObjectMeta: metav1.ObjectMeta{},
   171  		Spec:       v1alpha1.CmdSpec{},
   172  	}
   173  	var specArgs value.StringList
   174  	var dir value.LocalPath = value.NewLocalPathUnpacker(t)
   175  	err = dir.Unpack(starlark.String(""))
   176  	if err != nil {
   177  		return nil, err
   178  	}
   179  
   180  	var env value.StringList
   181  	var readinessProbe Probe = Probe{t: t}
   182  	var restartOn RestartOnSpec = RestartOnSpec{t: t}
   183  	var startOn StartOnSpec = StartOnSpec{t: t}
   184  	var disableSource DisableSource = DisableSource{t: t}
   185  	var labels value.StringStringMap
   186  	var annotations value.StringStringMap
   187  	err = starkit.UnpackArgs(t, fn.Name(), args, kwargs,
   188  		"name", &obj.ObjectMeta.Name,
   189  		"labels?", &labels,
   190  		"annotations?", &annotations,
   191  		"args?", &specArgs,
   192  		"dir?", &dir,
   193  		"env?", &env,
   194  		"readiness_probe?", &readinessProbe,
   195  		"restart_on?", &restartOn,
   196  		"start_on?", &startOn,
   197  		"disable_source?", &disableSource,
   198  	)
   199  	if err != nil {
   200  		return nil, err
   201  	}
   202  
   203  	obj.Spec.Args = specArgs
   204  	obj.Spec.Dir = dir.Value
   205  	obj.Spec.Env = env
   206  	if readinessProbe.isUnpacked {
   207  		obj.Spec.ReadinessProbe = (*v1alpha1.Probe)(&readinessProbe.Value)
   208  	}
   209  	if restartOn.isUnpacked {
   210  		obj.Spec.RestartOn = (*v1alpha1.RestartOnSpec)(&restartOn.Value)
   211  	}
   212  	if startOn.isUnpacked {
   213  		obj.Spec.StartOn = (*v1alpha1.StartOnSpec)(&startOn.Value)
   214  	}
   215  	if disableSource.isUnpacked {
   216  		obj.Spec.DisableSource = (*v1alpha1.DisableSource)(&disableSource.Value)
   217  	}
   218  	obj.ObjectMeta.Labels = labels
   219  	obj.ObjectMeta.Annotations = annotations
   220  	return p.register(t, obj)
   221  }
   222  
   223  func (p Plugin) configMap(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   224  	var err error
   225  	obj := &v1alpha1.ConfigMap{
   226  		ObjectMeta: metav1.ObjectMeta{},
   227  	}
   228  	var data value.StringStringMap
   229  	var labels value.StringStringMap
   230  	var annotations value.StringStringMap
   231  	err = starkit.UnpackArgs(t, fn.Name(), args, kwargs,
   232  		"name", &obj.ObjectMeta.Name,
   233  		"labels?", &labels,
   234  		"annotations?", &annotations,
   235  		"data?", &data,
   236  	)
   237  	if err != nil {
   238  		return nil, err
   239  	}
   240  
   241  	obj.Data = data
   242  	obj.ObjectMeta.Labels = labels
   243  	obj.ObjectMeta.Annotations = annotations
   244  	return p.register(t, obj)
   245  }
   246  
   247  func (p Plugin) extension(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   248  	var err error
   249  	obj := &v1alpha1.Extension{
   250  		ObjectMeta: metav1.ObjectMeta{},
   251  		Spec:       v1alpha1.ExtensionSpec{},
   252  	}
   253  	var specArgs value.StringList
   254  	var labels value.StringStringMap
   255  	var annotations value.StringStringMap
   256  	err = starkit.UnpackArgs(t, fn.Name(), args, kwargs,
   257  		"name", &obj.ObjectMeta.Name,
   258  		"labels?", &labels,
   259  		"annotations?", &annotations,
   260  		"repo_name?", &obj.Spec.RepoName,
   261  		"repo_path?", &obj.Spec.RepoPath,
   262  		"args?", &specArgs,
   263  	)
   264  	if err != nil {
   265  		return nil, err
   266  	}
   267  
   268  	obj.Spec.Args = specArgs
   269  	obj.ObjectMeta.Labels = labels
   270  	obj.ObjectMeta.Annotations = annotations
   271  	return p.register(t, obj)
   272  }
   273  
   274  func (p Plugin) extensionRepo(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   275  	var err error
   276  	obj := &v1alpha1.ExtensionRepo{
   277  		ObjectMeta: metav1.ObjectMeta{},
   278  		Spec:       v1alpha1.ExtensionRepoSpec{},
   279  	}
   280  	var labels value.StringStringMap
   281  	var annotations value.StringStringMap
   282  	err = starkit.UnpackArgs(t, fn.Name(), args, kwargs,
   283  		"name", &obj.ObjectMeta.Name,
   284  		"labels?", &labels,
   285  		"annotations?", &annotations,
   286  		"url?", &obj.Spec.URL,
   287  		"ref?", &obj.Spec.Ref,
   288  	)
   289  	if err != nil {
   290  		return nil, err
   291  	}
   292  
   293  	obj.ObjectMeta.Labels = labels
   294  	obj.ObjectMeta.Annotations = annotations
   295  	return p.register(t, obj)
   296  }
   297  
   298  func (p Plugin) fileWatch(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   299  	var err error
   300  	obj := &v1alpha1.FileWatch{
   301  		ObjectMeta: metav1.ObjectMeta{},
   302  		Spec:       v1alpha1.FileWatchSpec{},
   303  	}
   304  	var watchedPaths value.LocalPathList = value.NewLocalPathListUnpacker(t)
   305  	var ignores IgnoreDefList = IgnoreDefList{t: t}
   306  	var disableSource DisableSource = DisableSource{t: t}
   307  	var labels value.StringStringMap
   308  	var annotations value.StringStringMap
   309  	err = starkit.UnpackArgs(t, fn.Name(), args, kwargs,
   310  		"name", &obj.ObjectMeta.Name,
   311  		"labels?", &labels,
   312  		"annotations?", &annotations,
   313  		"watched_paths?", &watchedPaths,
   314  		"ignores?", &ignores,
   315  		"disable_source?", &disableSource,
   316  	)
   317  	if err != nil {
   318  		return nil, err
   319  	}
   320  
   321  	obj.Spec.WatchedPaths = watchedPaths.Value
   322  	obj.Spec.Ignores = ignores.Value
   323  	if disableSource.isUnpacked {
   324  		obj.Spec.DisableSource = (*v1alpha1.DisableSource)(&disableSource.Value)
   325  	}
   326  	obj.ObjectMeta.Labels = labels
   327  	obj.ObjectMeta.Annotations = annotations
   328  	return p.register(t, obj)
   329  }
   330  
   331  func (p Plugin) kubernetesApply(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   332  	var err error
   333  	obj := &v1alpha1.KubernetesApply{
   334  		ObjectMeta: metav1.ObjectMeta{},
   335  		Spec:       v1alpha1.KubernetesApplySpec{},
   336  	}
   337  	var imageMaps value.StringList
   338  	var imageLocators KubernetesImageLocatorList = KubernetesImageLocatorList{t: t}
   339  	var timeout value.Duration
   340  	var kubernetesDiscoveryTemplateSpec KubernetesDiscoveryTemplateSpec = KubernetesDiscoveryTemplateSpec{t: t}
   341  	var portForwardTemplateSpec PortForwardTemplateSpec = PortForwardTemplateSpec{t: t}
   342  	var podLogStreamTemplateSpec PodLogStreamTemplateSpec = PodLogStreamTemplateSpec{t: t}
   343  	var discoveryStrategy string
   344  	var disableSource DisableSource = DisableSource{t: t}
   345  	var applyCmd KubernetesApplyCmd = KubernetesApplyCmd{t: t}
   346  	var restartOn RestartOnSpec = RestartOnSpec{t: t}
   347  	var deleteCmd KubernetesApplyCmd = KubernetesApplyCmd{t: t}
   348  	var labels value.StringStringMap
   349  	var annotations value.StringStringMap
   350  	err = starkit.UnpackArgs(t, fn.Name(), args, kwargs,
   351  		"name", &obj.ObjectMeta.Name,
   352  		"labels?", &labels,
   353  		"annotations?", &annotations,
   354  		"yaml?", &obj.Spec.YAML,
   355  		"image_maps?", &imageMaps,
   356  		"image_locators?", &imageLocators,
   357  		"timeout?", &timeout,
   358  		"kubernetes_discovery_template_spec?", &kubernetesDiscoveryTemplateSpec,
   359  		"port_forward_template_spec?", &portForwardTemplateSpec,
   360  		"pod_log_stream_template_spec?", &podLogStreamTemplateSpec,
   361  		"discovery_strategy?", &discoveryStrategy,
   362  		"disable_source?", &disableSource,
   363  		"apply_cmd?", &applyCmd,
   364  		"restart_on?", &restartOn,
   365  		"delete_cmd?", &deleteCmd,
   366  		"cluster?", &obj.Spec.Cluster,
   367  	)
   368  	if err != nil {
   369  		return nil, err
   370  	}
   371  
   372  	obj.Spec.ImageMaps = imageMaps
   373  	obj.Spec.ImageLocators = imageLocators.Value
   374  	obj.Spec.Timeout = metav1.Duration{Duration: time.Duration(timeout)}
   375  	if kubernetesDiscoveryTemplateSpec.isUnpacked {
   376  		obj.Spec.KubernetesDiscoveryTemplateSpec = (*v1alpha1.KubernetesDiscoveryTemplateSpec)(&kubernetesDiscoveryTemplateSpec.Value)
   377  	}
   378  	if portForwardTemplateSpec.isUnpacked {
   379  		obj.Spec.PortForwardTemplateSpec = (*v1alpha1.PortForwardTemplateSpec)(&portForwardTemplateSpec.Value)
   380  	}
   381  	if podLogStreamTemplateSpec.isUnpacked {
   382  		obj.Spec.PodLogStreamTemplateSpec = (*v1alpha1.PodLogStreamTemplateSpec)(&podLogStreamTemplateSpec.Value)
   383  	}
   384  	obj.Spec.DiscoveryStrategy = v1alpha1.KubernetesDiscoveryStrategy(discoveryStrategy)
   385  	if disableSource.isUnpacked {
   386  		obj.Spec.DisableSource = (*v1alpha1.DisableSource)(&disableSource.Value)
   387  	}
   388  	if applyCmd.isUnpacked {
   389  		obj.Spec.ApplyCmd = (*v1alpha1.KubernetesApplyCmd)(&applyCmd.Value)
   390  	}
   391  	if restartOn.isUnpacked {
   392  		obj.Spec.RestartOn = (*v1alpha1.RestartOnSpec)(&restartOn.Value)
   393  	}
   394  	if deleteCmd.isUnpacked {
   395  		obj.Spec.DeleteCmd = (*v1alpha1.KubernetesApplyCmd)(&deleteCmd.Value)
   396  	}
   397  	obj.ObjectMeta.Labels = labels
   398  	obj.ObjectMeta.Annotations = annotations
   399  	return p.register(t, obj)
   400  }
   401  
   402  func (p Plugin) kubernetesDiscovery(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   403  	var err error
   404  	obj := &v1alpha1.KubernetesDiscovery{
   405  		ObjectMeta: metav1.ObjectMeta{},
   406  		Spec:       v1alpha1.KubernetesDiscoverySpec{},
   407  	}
   408  	var watches KubernetesWatchRefList = KubernetesWatchRefList{t: t}
   409  	var extraSelectors LabelSelectorList = LabelSelectorList{t: t}
   410  	var portForwardTemplateSpec PortForwardTemplateSpec = PortForwardTemplateSpec{t: t}
   411  	var podLogStreamTemplateSpec PodLogStreamTemplateSpec = PodLogStreamTemplateSpec{t: t}
   412  	var labels value.StringStringMap
   413  	var annotations value.StringStringMap
   414  	err = starkit.UnpackArgs(t, fn.Name(), args, kwargs,
   415  		"name", &obj.ObjectMeta.Name,
   416  		"labels?", &labels,
   417  		"annotations?", &annotations,
   418  		"watches?", &watches,
   419  		"extra_selectors?", &extraSelectors,
   420  		"port_forward_template_spec?", &portForwardTemplateSpec,
   421  		"pod_log_stream_template_spec?", &podLogStreamTemplateSpec,
   422  		"cluster?", &obj.Spec.Cluster,
   423  	)
   424  	if err != nil {
   425  		return nil, err
   426  	}
   427  
   428  	obj.Spec.Watches = watches.Value
   429  	obj.Spec.ExtraSelectors = extraSelectors.Value
   430  	if portForwardTemplateSpec.isUnpacked {
   431  		obj.Spec.PortForwardTemplateSpec = (*v1alpha1.PortForwardTemplateSpec)(&portForwardTemplateSpec.Value)
   432  	}
   433  	if podLogStreamTemplateSpec.isUnpacked {
   434  		obj.Spec.PodLogStreamTemplateSpec = (*v1alpha1.PodLogStreamTemplateSpec)(&podLogStreamTemplateSpec.Value)
   435  	}
   436  	obj.ObjectMeta.Labels = labels
   437  	obj.ObjectMeta.Annotations = annotations
   438  	return p.register(t, obj)
   439  }
   440  
   441  func (p Plugin) uiButton(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   442  	var err error
   443  	obj := &v1alpha1.UIButton{
   444  		ObjectMeta: metav1.ObjectMeta{},
   445  		Spec:       v1alpha1.UIButtonSpec{},
   446  	}
   447  	var location UIComponentLocation = UIComponentLocation{t: t}
   448  	var inputs UIInputSpecList = UIInputSpecList{t: t}
   449  	var labels value.StringStringMap
   450  	var annotations value.StringStringMap
   451  	err = starkit.UnpackArgs(t, fn.Name(), args, kwargs,
   452  		"name", &obj.ObjectMeta.Name,
   453  		"labels?", &labels,
   454  		"annotations?", &annotations,
   455  		"location?", &location,
   456  		"text?", &obj.Spec.Text,
   457  		"icon_name?", &obj.Spec.IconName,
   458  		"icon_svg?", &obj.Spec.IconSVG,
   459  		"disabled?", &obj.Spec.Disabled,
   460  		"requires_confirmation?", &obj.Spec.RequiresConfirmation,
   461  		"inputs?", &inputs,
   462  	)
   463  	if err != nil {
   464  		return nil, err
   465  	}
   466  
   467  	obj.Spec.Location = v1alpha1.UIComponentLocation(location.Value)
   468  	obj.Spec.Inputs = inputs.Value
   469  	obj.ObjectMeta.Labels = labels
   470  	obj.ObjectMeta.Annotations = annotations
   471  	return p.register(t, obj)
   472  }
   473  
   474  type ConfigMapDisableSource struct {
   475  	*starlark.Dict
   476  	Value      v1alpha1.ConfigMapDisableSource
   477  	isUnpacked bool
   478  	t          *starlark.Thread // instantiation thread for computing abspath
   479  }
   480  
   481  func (p Plugin) configMapDisableSource(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   482  	var name starlark.Value
   483  	var key starlark.Value
   484  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
   485  		"name?", &name,
   486  		"key?", &key,
   487  	)
   488  	if err != nil {
   489  		return nil, err
   490  	}
   491  
   492  	dict := starlark.NewDict(2)
   493  
   494  	if name != nil {
   495  		err := dict.SetKey(starlark.String("name"), name)
   496  		if err != nil {
   497  			return nil, err
   498  		}
   499  	}
   500  	if key != nil {
   501  		err := dict.SetKey(starlark.String("key"), key)
   502  		if err != nil {
   503  			return nil, err
   504  		}
   505  	}
   506  	var obj *ConfigMapDisableSource = &ConfigMapDisableSource{t: t}
   507  	err = obj.Unpack(dict)
   508  	if err != nil {
   509  		return nil, err
   510  	}
   511  	return obj, nil
   512  }
   513  
   514  func (o *ConfigMapDisableSource) Unpack(v starlark.Value) error {
   515  	obj := v1alpha1.ConfigMapDisableSource{}
   516  
   517  	starlarkObj, ok := v.(*ConfigMapDisableSource)
   518  	if ok {
   519  		*o = *starlarkObj
   520  		return nil
   521  	}
   522  
   523  	mapObj, ok := v.(*starlark.Dict)
   524  	if !ok {
   525  		return fmt.Errorf("expected dict, actual: %v", v.Type())
   526  	}
   527  
   528  	for _, item := range mapObj.Items() {
   529  		keyV, val := item[0], item[1]
   530  		key, ok := starlark.AsString(keyV)
   531  		if !ok {
   532  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
   533  		}
   534  
   535  		if key == "name" {
   536  			v, ok := starlark.AsString(val)
   537  			if !ok {
   538  				return fmt.Errorf("Expected string, actual: %s", val.Type())
   539  			}
   540  			obj.Name = string(v)
   541  			continue
   542  		}
   543  		if key == "key" {
   544  			v, ok := starlark.AsString(val)
   545  			if !ok {
   546  				return fmt.Errorf("Expected string, actual: %s", val.Type())
   547  			}
   548  			obj.Key = string(v)
   549  			continue
   550  		}
   551  		return fmt.Errorf("Unexpected attribute name: %s", key)
   552  	}
   553  
   554  	mapObj.Freeze()
   555  	o.Dict = mapObj
   556  	o.Value = obj
   557  	o.isUnpacked = true
   558  
   559  	return nil
   560  }
   561  
   562  type ConfigMapDisableSourceList struct {
   563  	*starlark.List
   564  	Value []v1alpha1.ConfigMapDisableSource
   565  	t     *starlark.Thread
   566  }
   567  
   568  func (o *ConfigMapDisableSourceList) Unpack(v starlark.Value) error {
   569  	items := []v1alpha1.ConfigMapDisableSource{}
   570  
   571  	listObj, ok := v.(*starlark.List)
   572  	if !ok {
   573  		return fmt.Errorf("expected list, actual: %v", v.Type())
   574  	}
   575  
   576  	for i := 0; i < listObj.Len(); i++ {
   577  		v := listObj.Index(i)
   578  
   579  		item := ConfigMapDisableSource{t: o.t}
   580  		err := item.Unpack(v)
   581  		if err != nil {
   582  			return fmt.Errorf("at index %d: %v", i, err)
   583  		}
   584  		items = append(items, v1alpha1.ConfigMapDisableSource(item.Value))
   585  	}
   586  
   587  	listObj.Freeze()
   588  	o.List = listObj
   589  	o.Value = items
   590  
   591  	return nil
   592  }
   593  
   594  type DisableSource struct {
   595  	*starlark.Dict
   596  	Value      v1alpha1.DisableSource
   597  	isUnpacked bool
   598  	t          *starlark.Thread // instantiation thread for computing abspath
   599  }
   600  
   601  func (p Plugin) disableSource(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   602  	var configMap starlark.Value
   603  	var everyConfigMap starlark.Value
   604  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
   605  		"config_map?", &configMap,
   606  		"every_config_map?", &everyConfigMap,
   607  	)
   608  	if err != nil {
   609  		return nil, err
   610  	}
   611  
   612  	dict := starlark.NewDict(2)
   613  
   614  	if configMap != nil {
   615  		err := dict.SetKey(starlark.String("config_map"), configMap)
   616  		if err != nil {
   617  			return nil, err
   618  		}
   619  	}
   620  	if everyConfigMap != nil {
   621  		err := dict.SetKey(starlark.String("every_config_map"), everyConfigMap)
   622  		if err != nil {
   623  			return nil, err
   624  		}
   625  	}
   626  	var obj *DisableSource = &DisableSource{t: t}
   627  	err = obj.Unpack(dict)
   628  	if err != nil {
   629  		return nil, err
   630  	}
   631  	return obj, nil
   632  }
   633  
   634  func (o *DisableSource) Unpack(v starlark.Value) error {
   635  	obj := v1alpha1.DisableSource{}
   636  
   637  	starlarkObj, ok := v.(*DisableSource)
   638  	if ok {
   639  		*o = *starlarkObj
   640  		return nil
   641  	}
   642  
   643  	mapObj, ok := v.(*starlark.Dict)
   644  	if !ok {
   645  		return fmt.Errorf("expected dict, actual: %v", v.Type())
   646  	}
   647  
   648  	for _, item := range mapObj.Items() {
   649  		keyV, val := item[0], item[1]
   650  		key, ok := starlark.AsString(keyV)
   651  		if !ok {
   652  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
   653  		}
   654  
   655  		if key == "config_map" {
   656  			v := ConfigMapDisableSource{t: o.t}
   657  			err := v.Unpack(val)
   658  			if err != nil {
   659  				return fmt.Errorf("unpacking %s: %v", key, err)
   660  			}
   661  			obj.ConfigMap = (*v1alpha1.ConfigMapDisableSource)(&v.Value)
   662  			continue
   663  		}
   664  		if key == "every_config_map" {
   665  			v := ConfigMapDisableSourceList{t: o.t}
   666  			err := v.Unpack(val)
   667  			if err != nil {
   668  				return fmt.Errorf("unpacking %s: %v", key, err)
   669  			}
   670  			obj.EveryConfigMap = v.Value
   671  			continue
   672  		}
   673  		return fmt.Errorf("Unexpected attribute name: %s", key)
   674  	}
   675  
   676  	mapObj.Freeze()
   677  	o.Dict = mapObj
   678  	o.Value = obj
   679  	o.isUnpacked = true
   680  
   681  	return nil
   682  }
   683  
   684  type DisableSourceList struct {
   685  	*starlark.List
   686  	Value []v1alpha1.DisableSource
   687  	t     *starlark.Thread
   688  }
   689  
   690  func (o *DisableSourceList) Unpack(v starlark.Value) error {
   691  	items := []v1alpha1.DisableSource{}
   692  
   693  	listObj, ok := v.(*starlark.List)
   694  	if !ok {
   695  		return fmt.Errorf("expected list, actual: %v", v.Type())
   696  	}
   697  
   698  	for i := 0; i < listObj.Len(); i++ {
   699  		v := listObj.Index(i)
   700  
   701  		item := DisableSource{t: o.t}
   702  		err := item.Unpack(v)
   703  		if err != nil {
   704  			return fmt.Errorf("at index %d: %v", i, err)
   705  		}
   706  		items = append(items, v1alpha1.DisableSource(item.Value))
   707  	}
   708  
   709  	listObj.Freeze()
   710  	o.List = listObj
   711  	o.Value = items
   712  
   713  	return nil
   714  }
   715  
   716  type ExecAction struct {
   717  	*starlark.Dict
   718  	Value      v1alpha1.ExecAction
   719  	isUnpacked bool
   720  	t          *starlark.Thread // instantiation thread for computing abspath
   721  }
   722  
   723  func (p Plugin) execAction(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   724  	var command starlark.Value
   725  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
   726  		"command?", &command,
   727  	)
   728  	if err != nil {
   729  		return nil, err
   730  	}
   731  
   732  	dict := starlark.NewDict(1)
   733  
   734  	if command != nil {
   735  		err := dict.SetKey(starlark.String("command"), command)
   736  		if err != nil {
   737  			return nil, err
   738  		}
   739  	}
   740  	var obj *ExecAction = &ExecAction{t: t}
   741  	err = obj.Unpack(dict)
   742  	if err != nil {
   743  		return nil, err
   744  	}
   745  	return obj, nil
   746  }
   747  
   748  func (o *ExecAction) Unpack(v starlark.Value) error {
   749  	obj := v1alpha1.ExecAction{}
   750  
   751  	starlarkObj, ok := v.(*ExecAction)
   752  	if ok {
   753  		*o = *starlarkObj
   754  		return nil
   755  	}
   756  
   757  	mapObj, ok := v.(*starlark.Dict)
   758  	if !ok {
   759  		return fmt.Errorf("expected dict, actual: %v", v.Type())
   760  	}
   761  
   762  	for _, item := range mapObj.Items() {
   763  		keyV, val := item[0], item[1]
   764  		key, ok := starlark.AsString(keyV)
   765  		if !ok {
   766  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
   767  		}
   768  
   769  		if key == "command" {
   770  			var v value.StringList
   771  			err := v.Unpack(val)
   772  			if err != nil {
   773  				return fmt.Errorf("unpacking %s: %v", key, err)
   774  			}
   775  			obj.Command = v
   776  			continue
   777  		}
   778  		return fmt.Errorf("Unexpected attribute name: %s", key)
   779  	}
   780  
   781  	mapObj.Freeze()
   782  	o.Dict = mapObj
   783  	o.Value = obj
   784  	o.isUnpacked = true
   785  
   786  	return nil
   787  }
   788  
   789  type ExecActionList struct {
   790  	*starlark.List
   791  	Value []v1alpha1.ExecAction
   792  	t     *starlark.Thread
   793  }
   794  
   795  func (o *ExecActionList) Unpack(v starlark.Value) error {
   796  	items := []v1alpha1.ExecAction{}
   797  
   798  	listObj, ok := v.(*starlark.List)
   799  	if !ok {
   800  		return fmt.Errorf("expected list, actual: %v", v.Type())
   801  	}
   802  
   803  	for i := 0; i < listObj.Len(); i++ {
   804  		v := listObj.Index(i)
   805  
   806  		item := ExecAction{t: o.t}
   807  		err := item.Unpack(v)
   808  		if err != nil {
   809  			return fmt.Errorf("at index %d: %v", i, err)
   810  		}
   811  		items = append(items, v1alpha1.ExecAction(item.Value))
   812  	}
   813  
   814  	listObj.Freeze()
   815  	o.List = listObj
   816  	o.Value = items
   817  
   818  	return nil
   819  }
   820  
   821  type Forward struct {
   822  	*starlark.Dict
   823  	Value      v1alpha1.Forward
   824  	isUnpacked bool
   825  	t          *starlark.Thread // instantiation thread for computing abspath
   826  }
   827  
   828  func (p Plugin) forward(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   829  	var localPort starlark.Value
   830  	var containerPort starlark.Value
   831  	var host starlark.Value
   832  	var name starlark.Value
   833  	var path starlark.Value
   834  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
   835  		"local_port?", &localPort,
   836  		"container_port?", &containerPort,
   837  		"host?", &host,
   838  		"name?", &name,
   839  		"path?", &path,
   840  	)
   841  	if err != nil {
   842  		return nil, err
   843  	}
   844  
   845  	dict := starlark.NewDict(5)
   846  
   847  	if localPort != nil {
   848  		err := dict.SetKey(starlark.String("local_port"), localPort)
   849  		if err != nil {
   850  			return nil, err
   851  		}
   852  	}
   853  	if containerPort != nil {
   854  		err := dict.SetKey(starlark.String("container_port"), containerPort)
   855  		if err != nil {
   856  			return nil, err
   857  		}
   858  	}
   859  	if host != nil {
   860  		err := dict.SetKey(starlark.String("host"), host)
   861  		if err != nil {
   862  			return nil, err
   863  		}
   864  	}
   865  	if name != nil {
   866  		err := dict.SetKey(starlark.String("name"), name)
   867  		if err != nil {
   868  			return nil, err
   869  		}
   870  	}
   871  	if path != nil {
   872  		err := dict.SetKey(starlark.String("path"), path)
   873  		if err != nil {
   874  			return nil, err
   875  		}
   876  	}
   877  	var obj *Forward = &Forward{t: t}
   878  	err = obj.Unpack(dict)
   879  	if err != nil {
   880  		return nil, err
   881  	}
   882  	return obj, nil
   883  }
   884  
   885  func (o *Forward) Unpack(v starlark.Value) error {
   886  	obj := v1alpha1.Forward{}
   887  
   888  	starlarkObj, ok := v.(*Forward)
   889  	if ok {
   890  		*o = *starlarkObj
   891  		return nil
   892  	}
   893  
   894  	mapObj, ok := v.(*starlark.Dict)
   895  	if !ok {
   896  		return fmt.Errorf("expected dict, actual: %v", v.Type())
   897  	}
   898  
   899  	for _, item := range mapObj.Items() {
   900  		keyV, val := item[0], item[1]
   901  		key, ok := starlark.AsString(keyV)
   902  		if !ok {
   903  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
   904  		}
   905  
   906  		if key == "local_port" {
   907  			v, err := starlark.AsInt32(val)
   908  			if err != nil {
   909  				return fmt.Errorf("Expected int, got: %v", err)
   910  			}
   911  			obj.LocalPort = int32(v)
   912  			continue
   913  		}
   914  		if key == "container_port" {
   915  			v, err := starlark.AsInt32(val)
   916  			if err != nil {
   917  				return fmt.Errorf("Expected int, got: %v", err)
   918  			}
   919  			obj.ContainerPort = int32(v)
   920  			continue
   921  		}
   922  		if key == "host" {
   923  			v, ok := starlark.AsString(val)
   924  			if !ok {
   925  				return fmt.Errorf("Expected string, actual: %s", val.Type())
   926  			}
   927  			obj.Host = string(v)
   928  			continue
   929  		}
   930  		if key == "name" {
   931  			v, ok := starlark.AsString(val)
   932  			if !ok {
   933  				return fmt.Errorf("Expected string, actual: %s", val.Type())
   934  			}
   935  			obj.Name = string(v)
   936  			continue
   937  		}
   938  		if key == "path" {
   939  			v, ok := starlark.AsString(val)
   940  			if !ok {
   941  				return fmt.Errorf("Expected string, actual: %s", val.Type())
   942  			}
   943  			obj.Path = string(v)
   944  			continue
   945  		}
   946  		return fmt.Errorf("Unexpected attribute name: %s", key)
   947  	}
   948  
   949  	mapObj.Freeze()
   950  	o.Dict = mapObj
   951  	o.Value = obj
   952  	o.isUnpacked = true
   953  
   954  	return nil
   955  }
   956  
   957  type ForwardList struct {
   958  	*starlark.List
   959  	Value []v1alpha1.Forward
   960  	t     *starlark.Thread
   961  }
   962  
   963  func (o *ForwardList) Unpack(v starlark.Value) error {
   964  	items := []v1alpha1.Forward{}
   965  
   966  	listObj, ok := v.(*starlark.List)
   967  	if !ok {
   968  		return fmt.Errorf("expected list, actual: %v", v.Type())
   969  	}
   970  
   971  	for i := 0; i < listObj.Len(); i++ {
   972  		v := listObj.Index(i)
   973  
   974  		item := Forward{t: o.t}
   975  		err := item.Unpack(v)
   976  		if err != nil {
   977  			return fmt.Errorf("at index %d: %v", i, err)
   978  		}
   979  		items = append(items, v1alpha1.Forward(item.Value))
   980  	}
   981  
   982  	listObj.Freeze()
   983  	o.List = listObj
   984  	o.Value = items
   985  
   986  	return nil
   987  }
   988  
   989  type HTTPGetAction struct {
   990  	*starlark.Dict
   991  	Value      v1alpha1.HTTPGetAction
   992  	isUnpacked bool
   993  	t          *starlark.Thread // instantiation thread for computing abspath
   994  }
   995  
   996  func (p Plugin) hTTPGetAction(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
   997  	var path starlark.Value
   998  	var port starlark.Value
   999  	var host starlark.Value
  1000  	var scheme starlark.Value
  1001  	var hTTPHeaders starlark.Value
  1002  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
  1003  		"path?", &path,
  1004  		"port?", &port,
  1005  		"host?", &host,
  1006  		"scheme?", &scheme,
  1007  		"http_headers?", &hTTPHeaders,
  1008  	)
  1009  	if err != nil {
  1010  		return nil, err
  1011  	}
  1012  
  1013  	dict := starlark.NewDict(5)
  1014  
  1015  	if path != nil {
  1016  		err := dict.SetKey(starlark.String("path"), path)
  1017  		if err != nil {
  1018  			return nil, err
  1019  		}
  1020  	}
  1021  	if port != nil {
  1022  		err := dict.SetKey(starlark.String("port"), port)
  1023  		if err != nil {
  1024  			return nil, err
  1025  		}
  1026  	}
  1027  	if host != nil {
  1028  		err := dict.SetKey(starlark.String("host"), host)
  1029  		if err != nil {
  1030  			return nil, err
  1031  		}
  1032  	}
  1033  	if scheme != nil {
  1034  		err := dict.SetKey(starlark.String("scheme"), scheme)
  1035  		if err != nil {
  1036  			return nil, err
  1037  		}
  1038  	}
  1039  	if hTTPHeaders != nil {
  1040  		err := dict.SetKey(starlark.String("http_headers"), hTTPHeaders)
  1041  		if err != nil {
  1042  			return nil, err
  1043  		}
  1044  	}
  1045  	var obj *HTTPGetAction = &HTTPGetAction{t: t}
  1046  	err = obj.Unpack(dict)
  1047  	if err != nil {
  1048  		return nil, err
  1049  	}
  1050  	return obj, nil
  1051  }
  1052  
  1053  func (o *HTTPGetAction) Unpack(v starlark.Value) error {
  1054  	obj := v1alpha1.HTTPGetAction{}
  1055  
  1056  	starlarkObj, ok := v.(*HTTPGetAction)
  1057  	if ok {
  1058  		*o = *starlarkObj
  1059  		return nil
  1060  	}
  1061  
  1062  	mapObj, ok := v.(*starlark.Dict)
  1063  	if !ok {
  1064  		return fmt.Errorf("expected dict, actual: %v", v.Type())
  1065  	}
  1066  
  1067  	for _, item := range mapObj.Items() {
  1068  		keyV, val := item[0], item[1]
  1069  		key, ok := starlark.AsString(keyV)
  1070  		if !ok {
  1071  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
  1072  		}
  1073  
  1074  		if key == "path" {
  1075  			v, ok := starlark.AsString(val)
  1076  			if !ok {
  1077  				return fmt.Errorf("Expected string, actual: %s", val.Type())
  1078  			}
  1079  			obj.Path = string(v)
  1080  			continue
  1081  		}
  1082  		if key == "port" {
  1083  			v, err := starlark.AsInt32(val)
  1084  			if err != nil {
  1085  				return fmt.Errorf("Expected int, got: %v", err)
  1086  			}
  1087  			obj.Port = int32(v)
  1088  			continue
  1089  		}
  1090  		if key == "host" {
  1091  			v, ok := starlark.AsString(val)
  1092  			if !ok {
  1093  				return fmt.Errorf("Expected string, actual: %s", val.Type())
  1094  			}
  1095  			obj.Host = string(v)
  1096  			continue
  1097  		}
  1098  		if key == "scheme" {
  1099  			v, ok := starlark.AsString(val)
  1100  			if !ok {
  1101  				return fmt.Errorf("Expected string, actual: %s", val.Type())
  1102  			}
  1103  			obj.Scheme = v1alpha1.URIScheme(v)
  1104  			continue
  1105  		}
  1106  		if key == "http_headers" {
  1107  			v := HTTPHeaderList{t: o.t}
  1108  			err := v.Unpack(val)
  1109  			if err != nil {
  1110  				return fmt.Errorf("unpacking %s: %v", key, err)
  1111  			}
  1112  			obj.HTTPHeaders = v.Value
  1113  			continue
  1114  		}
  1115  		return fmt.Errorf("Unexpected attribute name: %s", key)
  1116  	}
  1117  
  1118  	mapObj.Freeze()
  1119  	o.Dict = mapObj
  1120  	o.Value = obj
  1121  	o.isUnpacked = true
  1122  
  1123  	return nil
  1124  }
  1125  
  1126  type HTTPGetActionList struct {
  1127  	*starlark.List
  1128  	Value []v1alpha1.HTTPGetAction
  1129  	t     *starlark.Thread
  1130  }
  1131  
  1132  func (o *HTTPGetActionList) Unpack(v starlark.Value) error {
  1133  	items := []v1alpha1.HTTPGetAction{}
  1134  
  1135  	listObj, ok := v.(*starlark.List)
  1136  	if !ok {
  1137  		return fmt.Errorf("expected list, actual: %v", v.Type())
  1138  	}
  1139  
  1140  	for i := 0; i < listObj.Len(); i++ {
  1141  		v := listObj.Index(i)
  1142  
  1143  		item := HTTPGetAction{t: o.t}
  1144  		err := item.Unpack(v)
  1145  		if err != nil {
  1146  			return fmt.Errorf("at index %d: %v", i, err)
  1147  		}
  1148  		items = append(items, v1alpha1.HTTPGetAction(item.Value))
  1149  	}
  1150  
  1151  	listObj.Freeze()
  1152  	o.List = listObj
  1153  	o.Value = items
  1154  
  1155  	return nil
  1156  }
  1157  
  1158  type HTTPHeader struct {
  1159  	*starlark.Dict
  1160  	Value      v1alpha1.HTTPHeader
  1161  	isUnpacked bool
  1162  	t          *starlark.Thread // instantiation thread for computing abspath
  1163  }
  1164  
  1165  func (p Plugin) hTTPHeader(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  1166  	var name starlark.Value
  1167  	var value starlark.Value
  1168  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
  1169  		"name?", &name,
  1170  		"value?", &value,
  1171  	)
  1172  	if err != nil {
  1173  		return nil, err
  1174  	}
  1175  
  1176  	dict := starlark.NewDict(2)
  1177  
  1178  	if name != nil {
  1179  		err := dict.SetKey(starlark.String("name"), name)
  1180  		if err != nil {
  1181  			return nil, err
  1182  		}
  1183  	}
  1184  	if value != nil {
  1185  		err := dict.SetKey(starlark.String("value"), value)
  1186  		if err != nil {
  1187  			return nil, err
  1188  		}
  1189  	}
  1190  	var obj *HTTPHeader = &HTTPHeader{t: t}
  1191  	err = obj.Unpack(dict)
  1192  	if err != nil {
  1193  		return nil, err
  1194  	}
  1195  	return obj, nil
  1196  }
  1197  
  1198  func (o *HTTPHeader) Unpack(v starlark.Value) error {
  1199  	obj := v1alpha1.HTTPHeader{}
  1200  
  1201  	starlarkObj, ok := v.(*HTTPHeader)
  1202  	if ok {
  1203  		*o = *starlarkObj
  1204  		return nil
  1205  	}
  1206  
  1207  	mapObj, ok := v.(*starlark.Dict)
  1208  	if !ok {
  1209  		return fmt.Errorf("expected dict, actual: %v", v.Type())
  1210  	}
  1211  
  1212  	for _, item := range mapObj.Items() {
  1213  		keyV, val := item[0], item[1]
  1214  		key, ok := starlark.AsString(keyV)
  1215  		if !ok {
  1216  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
  1217  		}
  1218  
  1219  		if key == "name" {
  1220  			v, ok := starlark.AsString(val)
  1221  			if !ok {
  1222  				return fmt.Errorf("Expected string, actual: %s", val.Type())
  1223  			}
  1224  			obj.Name = string(v)
  1225  			continue
  1226  		}
  1227  		if key == "value" {
  1228  			v, ok := starlark.AsString(val)
  1229  			if !ok {
  1230  				return fmt.Errorf("Expected string, actual: %s", val.Type())
  1231  			}
  1232  			obj.Value = string(v)
  1233  			continue
  1234  		}
  1235  		return fmt.Errorf("Unexpected attribute name: %s", key)
  1236  	}
  1237  
  1238  	mapObj.Freeze()
  1239  	o.Dict = mapObj
  1240  	o.Value = obj
  1241  	o.isUnpacked = true
  1242  
  1243  	return nil
  1244  }
  1245  
  1246  type HTTPHeaderList struct {
  1247  	*starlark.List
  1248  	Value []v1alpha1.HTTPHeader
  1249  	t     *starlark.Thread
  1250  }
  1251  
  1252  func (o *HTTPHeaderList) Unpack(v starlark.Value) error {
  1253  	items := []v1alpha1.HTTPHeader{}
  1254  
  1255  	listObj, ok := v.(*starlark.List)
  1256  	if !ok {
  1257  		return fmt.Errorf("expected list, actual: %v", v.Type())
  1258  	}
  1259  
  1260  	for i := 0; i < listObj.Len(); i++ {
  1261  		v := listObj.Index(i)
  1262  
  1263  		item := HTTPHeader{t: o.t}
  1264  		err := item.Unpack(v)
  1265  		if err != nil {
  1266  			return fmt.Errorf("at index %d: %v", i, err)
  1267  		}
  1268  		items = append(items, v1alpha1.HTTPHeader(item.Value))
  1269  	}
  1270  
  1271  	listObj.Freeze()
  1272  	o.List = listObj
  1273  	o.Value = items
  1274  
  1275  	return nil
  1276  }
  1277  
  1278  type Handler struct {
  1279  	*starlark.Dict
  1280  	Value      v1alpha1.Handler
  1281  	isUnpacked bool
  1282  	t          *starlark.Thread // instantiation thread for computing abspath
  1283  }
  1284  
  1285  func (p Plugin) handler(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  1286  	var exec starlark.Value
  1287  	var hTTPGet starlark.Value
  1288  	var tCPSocket starlark.Value
  1289  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
  1290  		"exec?", &exec,
  1291  		"http_get?", &hTTPGet,
  1292  		"tcp_socket?", &tCPSocket,
  1293  	)
  1294  	if err != nil {
  1295  		return nil, err
  1296  	}
  1297  
  1298  	dict := starlark.NewDict(3)
  1299  
  1300  	if exec != nil {
  1301  		err := dict.SetKey(starlark.String("exec"), exec)
  1302  		if err != nil {
  1303  			return nil, err
  1304  		}
  1305  	}
  1306  	if hTTPGet != nil {
  1307  		err := dict.SetKey(starlark.String("http_get"), hTTPGet)
  1308  		if err != nil {
  1309  			return nil, err
  1310  		}
  1311  	}
  1312  	if tCPSocket != nil {
  1313  		err := dict.SetKey(starlark.String("tcp_socket"), tCPSocket)
  1314  		if err != nil {
  1315  			return nil, err
  1316  		}
  1317  	}
  1318  	var obj *Handler = &Handler{t: t}
  1319  	err = obj.Unpack(dict)
  1320  	if err != nil {
  1321  		return nil, err
  1322  	}
  1323  	return obj, nil
  1324  }
  1325  
  1326  func (o *Handler) Unpack(v starlark.Value) error {
  1327  	obj := v1alpha1.Handler{}
  1328  
  1329  	starlarkObj, ok := v.(*Handler)
  1330  	if ok {
  1331  		*o = *starlarkObj
  1332  		return nil
  1333  	}
  1334  
  1335  	mapObj, ok := v.(*starlark.Dict)
  1336  	if !ok {
  1337  		return fmt.Errorf("expected dict, actual: %v", v.Type())
  1338  	}
  1339  
  1340  	for _, item := range mapObj.Items() {
  1341  		keyV, val := item[0], item[1]
  1342  		key, ok := starlark.AsString(keyV)
  1343  		if !ok {
  1344  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
  1345  		}
  1346  
  1347  		if key == "exec" {
  1348  			v := ExecAction{t: o.t}
  1349  			err := v.Unpack(val)
  1350  			if err != nil {
  1351  				return fmt.Errorf("unpacking %s: %v", key, err)
  1352  			}
  1353  			obj.Exec = (*v1alpha1.ExecAction)(&v.Value)
  1354  			continue
  1355  		}
  1356  		if key == "http_get" {
  1357  			v := HTTPGetAction{t: o.t}
  1358  			err := v.Unpack(val)
  1359  			if err != nil {
  1360  				return fmt.Errorf("unpacking %s: %v", key, err)
  1361  			}
  1362  			obj.HTTPGet = (*v1alpha1.HTTPGetAction)(&v.Value)
  1363  			continue
  1364  		}
  1365  		if key == "tcp_socket" {
  1366  			v := TCPSocketAction{t: o.t}
  1367  			err := v.Unpack(val)
  1368  			if err != nil {
  1369  				return fmt.Errorf("unpacking %s: %v", key, err)
  1370  			}
  1371  			obj.TCPSocket = (*v1alpha1.TCPSocketAction)(&v.Value)
  1372  			continue
  1373  		}
  1374  		return fmt.Errorf("Unexpected attribute name: %s", key)
  1375  	}
  1376  
  1377  	mapObj.Freeze()
  1378  	o.Dict = mapObj
  1379  	o.Value = obj
  1380  	o.isUnpacked = true
  1381  
  1382  	return nil
  1383  }
  1384  
  1385  type HandlerList struct {
  1386  	*starlark.List
  1387  	Value []v1alpha1.Handler
  1388  	t     *starlark.Thread
  1389  }
  1390  
  1391  func (o *HandlerList) Unpack(v starlark.Value) error {
  1392  	items := []v1alpha1.Handler{}
  1393  
  1394  	listObj, ok := v.(*starlark.List)
  1395  	if !ok {
  1396  		return fmt.Errorf("expected list, actual: %v", v.Type())
  1397  	}
  1398  
  1399  	for i := 0; i < listObj.Len(); i++ {
  1400  		v := listObj.Index(i)
  1401  
  1402  		item := Handler{t: o.t}
  1403  		err := item.Unpack(v)
  1404  		if err != nil {
  1405  			return fmt.Errorf("at index %d: %v", i, err)
  1406  		}
  1407  		items = append(items, v1alpha1.Handler(item.Value))
  1408  	}
  1409  
  1410  	listObj.Freeze()
  1411  	o.List = listObj
  1412  	o.Value = items
  1413  
  1414  	return nil
  1415  }
  1416  
  1417  type IgnoreDef struct {
  1418  	*starlark.Dict
  1419  	Value      v1alpha1.IgnoreDef
  1420  	isUnpacked bool
  1421  	t          *starlark.Thread // instantiation thread for computing abspath
  1422  }
  1423  
  1424  func (p Plugin) ignoreDef(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  1425  	var basePath starlark.Value
  1426  	var patterns starlark.Value
  1427  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
  1428  		"base_path?", &basePath,
  1429  		"patterns?", &patterns,
  1430  	)
  1431  	if err != nil {
  1432  		return nil, err
  1433  	}
  1434  
  1435  	dict := starlark.NewDict(2)
  1436  
  1437  	if basePath != nil {
  1438  		err := dict.SetKey(starlark.String("base_path"), basePath)
  1439  		if err != nil {
  1440  			return nil, err
  1441  		}
  1442  	}
  1443  	if patterns != nil {
  1444  		err := dict.SetKey(starlark.String("patterns"), patterns)
  1445  		if err != nil {
  1446  			return nil, err
  1447  		}
  1448  	}
  1449  	var obj *IgnoreDef = &IgnoreDef{t: t}
  1450  	err = obj.Unpack(dict)
  1451  	if err != nil {
  1452  		return nil, err
  1453  	}
  1454  	return obj, nil
  1455  }
  1456  
  1457  func (o *IgnoreDef) Unpack(v starlark.Value) error {
  1458  	obj := v1alpha1.IgnoreDef{}
  1459  
  1460  	starlarkObj, ok := v.(*IgnoreDef)
  1461  	if ok {
  1462  		*o = *starlarkObj
  1463  		return nil
  1464  	}
  1465  
  1466  	mapObj, ok := v.(*starlark.Dict)
  1467  	if !ok {
  1468  		return fmt.Errorf("expected dict, actual: %v", v.Type())
  1469  	}
  1470  
  1471  	for _, item := range mapObj.Items() {
  1472  		keyV, val := item[0], item[1]
  1473  		key, ok := starlark.AsString(keyV)
  1474  		if !ok {
  1475  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
  1476  		}
  1477  
  1478  		if key == "base_path" {
  1479  			v := value.NewLocalPathUnpacker(o.t)
  1480  			err := v.Unpack(val)
  1481  			if err != nil {
  1482  				return fmt.Errorf("unpacking %s: %v", key, err)
  1483  			}
  1484  			obj.BasePath = v.Value
  1485  			continue
  1486  		}
  1487  		if key == "patterns" {
  1488  			var v value.StringList
  1489  			err := v.Unpack(val)
  1490  			if err != nil {
  1491  				return fmt.Errorf("unpacking %s: %v", key, err)
  1492  			}
  1493  			obj.Patterns = v
  1494  			continue
  1495  		}
  1496  		return fmt.Errorf("Unexpected attribute name: %s", key)
  1497  	}
  1498  
  1499  	mapObj.Freeze()
  1500  	o.Dict = mapObj
  1501  	o.Value = obj
  1502  	o.isUnpacked = true
  1503  
  1504  	return nil
  1505  }
  1506  
  1507  type IgnoreDefList struct {
  1508  	*starlark.List
  1509  	Value []v1alpha1.IgnoreDef
  1510  	t     *starlark.Thread
  1511  }
  1512  
  1513  func (o *IgnoreDefList) Unpack(v starlark.Value) error {
  1514  	items := []v1alpha1.IgnoreDef{}
  1515  
  1516  	listObj, ok := v.(*starlark.List)
  1517  	if !ok {
  1518  		return fmt.Errorf("expected list, actual: %v", v.Type())
  1519  	}
  1520  
  1521  	for i := 0; i < listObj.Len(); i++ {
  1522  		v := listObj.Index(i)
  1523  
  1524  		item := IgnoreDef{t: o.t}
  1525  		err := item.Unpack(v)
  1526  		if err != nil {
  1527  			return fmt.Errorf("at index %d: %v", i, err)
  1528  		}
  1529  		items = append(items, v1alpha1.IgnoreDef(item.Value))
  1530  	}
  1531  
  1532  	listObj.Freeze()
  1533  	o.List = listObj
  1534  	o.Value = items
  1535  
  1536  	return nil
  1537  }
  1538  
  1539  type KubernetesApplyCmd struct {
  1540  	*starlark.Dict
  1541  	Value      v1alpha1.KubernetesApplyCmd
  1542  	isUnpacked bool
  1543  	t          *starlark.Thread // instantiation thread for computing abspath
  1544  }
  1545  
  1546  func (p Plugin) kubernetesApplyCmd(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  1547  	var specArgs starlark.Value
  1548  	var dir starlark.Value
  1549  	var env starlark.Value
  1550  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
  1551  		"args?", &specArgs,
  1552  		"dir?", &dir,
  1553  		"env?", &env,
  1554  	)
  1555  	if err != nil {
  1556  		return nil, err
  1557  	}
  1558  
  1559  	dict := starlark.NewDict(3)
  1560  
  1561  	if specArgs != nil {
  1562  		err := dict.SetKey(starlark.String("args"), specArgs)
  1563  		if err != nil {
  1564  			return nil, err
  1565  		}
  1566  	}
  1567  	if dir != nil {
  1568  		err := dict.SetKey(starlark.String("dir"), dir)
  1569  		if err != nil {
  1570  			return nil, err
  1571  		}
  1572  	}
  1573  	if env != nil {
  1574  		err := dict.SetKey(starlark.String("env"), env)
  1575  		if err != nil {
  1576  			return nil, err
  1577  		}
  1578  	}
  1579  	var obj *KubernetesApplyCmd = &KubernetesApplyCmd{t: t}
  1580  	err = obj.Unpack(dict)
  1581  	if err != nil {
  1582  		return nil, err
  1583  	}
  1584  	return obj, nil
  1585  }
  1586  
  1587  func (o *KubernetesApplyCmd) Unpack(v starlark.Value) error {
  1588  	obj := v1alpha1.KubernetesApplyCmd{}
  1589  
  1590  	starlarkObj, ok := v.(*KubernetesApplyCmd)
  1591  	if ok {
  1592  		*o = *starlarkObj
  1593  		return nil
  1594  	}
  1595  
  1596  	mapObj, ok := v.(*starlark.Dict)
  1597  	if !ok {
  1598  		return fmt.Errorf("expected dict, actual: %v", v.Type())
  1599  	}
  1600  
  1601  	for _, item := range mapObj.Items() {
  1602  		keyV, val := item[0], item[1]
  1603  		key, ok := starlark.AsString(keyV)
  1604  		if !ok {
  1605  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
  1606  		}
  1607  
  1608  		if key == "args" {
  1609  			var v value.StringList
  1610  			err := v.Unpack(val)
  1611  			if err != nil {
  1612  				return fmt.Errorf("unpacking %s: %v", key, err)
  1613  			}
  1614  			obj.Args = v
  1615  			continue
  1616  		}
  1617  		if key == "dir" {
  1618  			v := value.NewLocalPathUnpacker(o.t)
  1619  			err := v.Unpack(val)
  1620  			if err != nil {
  1621  				return fmt.Errorf("unpacking %s: %v", key, err)
  1622  			}
  1623  			obj.Dir = v.Value
  1624  			continue
  1625  		}
  1626  		if key == "env" {
  1627  			var v value.StringList
  1628  			err := v.Unpack(val)
  1629  			if err != nil {
  1630  				return fmt.Errorf("unpacking %s: %v", key, err)
  1631  			}
  1632  			obj.Env = v
  1633  			continue
  1634  		}
  1635  		return fmt.Errorf("Unexpected attribute name: %s", key)
  1636  	}
  1637  
  1638  	mapObj.Freeze()
  1639  	o.Dict = mapObj
  1640  	o.Value = obj
  1641  	o.isUnpacked = true
  1642  
  1643  	return nil
  1644  }
  1645  
  1646  type KubernetesApplyCmdList struct {
  1647  	*starlark.List
  1648  	Value []v1alpha1.KubernetesApplyCmd
  1649  	t     *starlark.Thread
  1650  }
  1651  
  1652  func (o *KubernetesApplyCmdList) Unpack(v starlark.Value) error {
  1653  	items := []v1alpha1.KubernetesApplyCmd{}
  1654  
  1655  	listObj, ok := v.(*starlark.List)
  1656  	if !ok {
  1657  		return fmt.Errorf("expected list, actual: %v", v.Type())
  1658  	}
  1659  
  1660  	for i := 0; i < listObj.Len(); i++ {
  1661  		v := listObj.Index(i)
  1662  
  1663  		item := KubernetesApplyCmd{t: o.t}
  1664  		err := item.Unpack(v)
  1665  		if err != nil {
  1666  			return fmt.Errorf("at index %d: %v", i, err)
  1667  		}
  1668  		items = append(items, v1alpha1.KubernetesApplyCmd(item.Value))
  1669  	}
  1670  
  1671  	listObj.Freeze()
  1672  	o.List = listObj
  1673  	o.Value = items
  1674  
  1675  	return nil
  1676  }
  1677  
  1678  type KubernetesDiscoveryTemplateSpec struct {
  1679  	*starlark.Dict
  1680  	Value      v1alpha1.KubernetesDiscoveryTemplateSpec
  1681  	isUnpacked bool
  1682  	t          *starlark.Thread // instantiation thread for computing abspath
  1683  }
  1684  
  1685  func (p Plugin) kubernetesDiscoveryTemplateSpec(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  1686  	var extraSelectors starlark.Value
  1687  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
  1688  		"extra_selectors?", &extraSelectors,
  1689  	)
  1690  	if err != nil {
  1691  		return nil, err
  1692  	}
  1693  
  1694  	dict := starlark.NewDict(1)
  1695  
  1696  	if extraSelectors != nil {
  1697  		err := dict.SetKey(starlark.String("extra_selectors"), extraSelectors)
  1698  		if err != nil {
  1699  			return nil, err
  1700  		}
  1701  	}
  1702  	var obj *KubernetesDiscoveryTemplateSpec = &KubernetesDiscoveryTemplateSpec{t: t}
  1703  	err = obj.Unpack(dict)
  1704  	if err != nil {
  1705  		return nil, err
  1706  	}
  1707  	return obj, nil
  1708  }
  1709  
  1710  func (o *KubernetesDiscoveryTemplateSpec) Unpack(v starlark.Value) error {
  1711  	obj := v1alpha1.KubernetesDiscoveryTemplateSpec{}
  1712  
  1713  	starlarkObj, ok := v.(*KubernetesDiscoveryTemplateSpec)
  1714  	if ok {
  1715  		*o = *starlarkObj
  1716  		return nil
  1717  	}
  1718  
  1719  	mapObj, ok := v.(*starlark.Dict)
  1720  	if !ok {
  1721  		return fmt.Errorf("expected dict, actual: %v", v.Type())
  1722  	}
  1723  
  1724  	for _, item := range mapObj.Items() {
  1725  		keyV, val := item[0], item[1]
  1726  		key, ok := starlark.AsString(keyV)
  1727  		if !ok {
  1728  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
  1729  		}
  1730  
  1731  		if key == "extra_selectors" {
  1732  			v := LabelSelectorList{t: o.t}
  1733  			err := v.Unpack(val)
  1734  			if err != nil {
  1735  				return fmt.Errorf("unpacking %s: %v", key, err)
  1736  			}
  1737  			obj.ExtraSelectors = v.Value
  1738  			continue
  1739  		}
  1740  		return fmt.Errorf("Unexpected attribute name: %s", key)
  1741  	}
  1742  
  1743  	mapObj.Freeze()
  1744  	o.Dict = mapObj
  1745  	o.Value = obj
  1746  	o.isUnpacked = true
  1747  
  1748  	return nil
  1749  }
  1750  
  1751  type KubernetesDiscoveryTemplateSpecList struct {
  1752  	*starlark.List
  1753  	Value []v1alpha1.KubernetesDiscoveryTemplateSpec
  1754  	t     *starlark.Thread
  1755  }
  1756  
  1757  func (o *KubernetesDiscoveryTemplateSpecList) Unpack(v starlark.Value) error {
  1758  	items := []v1alpha1.KubernetesDiscoveryTemplateSpec{}
  1759  
  1760  	listObj, ok := v.(*starlark.List)
  1761  	if !ok {
  1762  		return fmt.Errorf("expected list, actual: %v", v.Type())
  1763  	}
  1764  
  1765  	for i := 0; i < listObj.Len(); i++ {
  1766  		v := listObj.Index(i)
  1767  
  1768  		item := KubernetesDiscoveryTemplateSpec{t: o.t}
  1769  		err := item.Unpack(v)
  1770  		if err != nil {
  1771  			return fmt.Errorf("at index %d: %v", i, err)
  1772  		}
  1773  		items = append(items, v1alpha1.KubernetesDiscoveryTemplateSpec(item.Value))
  1774  	}
  1775  
  1776  	listObj.Freeze()
  1777  	o.List = listObj
  1778  	o.Value = items
  1779  
  1780  	return nil
  1781  }
  1782  
  1783  type KubernetesImageLocator struct {
  1784  	*starlark.Dict
  1785  	Value      v1alpha1.KubernetesImageLocator
  1786  	isUnpacked bool
  1787  	t          *starlark.Thread // instantiation thread for computing abspath
  1788  }
  1789  
  1790  func (p Plugin) kubernetesImageLocator(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  1791  	var objectSelector starlark.Value
  1792  	var path starlark.Value
  1793  	var object starlark.Value
  1794  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
  1795  		"object_selector?", &objectSelector,
  1796  		"path?", &path,
  1797  		"object?", &object,
  1798  	)
  1799  	if err != nil {
  1800  		return nil, err
  1801  	}
  1802  
  1803  	dict := starlark.NewDict(3)
  1804  
  1805  	if objectSelector != nil {
  1806  		err := dict.SetKey(starlark.String("object_selector"), objectSelector)
  1807  		if err != nil {
  1808  			return nil, err
  1809  		}
  1810  	}
  1811  	if path != nil {
  1812  		err := dict.SetKey(starlark.String("path"), path)
  1813  		if err != nil {
  1814  			return nil, err
  1815  		}
  1816  	}
  1817  	if object != nil {
  1818  		err := dict.SetKey(starlark.String("object"), object)
  1819  		if err != nil {
  1820  			return nil, err
  1821  		}
  1822  	}
  1823  	var obj *KubernetesImageLocator = &KubernetesImageLocator{t: t}
  1824  	err = obj.Unpack(dict)
  1825  	if err != nil {
  1826  		return nil, err
  1827  	}
  1828  	return obj, nil
  1829  }
  1830  
  1831  func (o *KubernetesImageLocator) Unpack(v starlark.Value) error {
  1832  	obj := v1alpha1.KubernetesImageLocator{}
  1833  
  1834  	starlarkObj, ok := v.(*KubernetesImageLocator)
  1835  	if ok {
  1836  		*o = *starlarkObj
  1837  		return nil
  1838  	}
  1839  
  1840  	mapObj, ok := v.(*starlark.Dict)
  1841  	if !ok {
  1842  		return fmt.Errorf("expected dict, actual: %v", v.Type())
  1843  	}
  1844  
  1845  	for _, item := range mapObj.Items() {
  1846  		keyV, val := item[0], item[1]
  1847  		key, ok := starlark.AsString(keyV)
  1848  		if !ok {
  1849  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
  1850  		}
  1851  
  1852  		if key == "object_selector" {
  1853  			v := ObjectSelector{t: o.t}
  1854  			err := v.Unpack(val)
  1855  			if err != nil {
  1856  				return fmt.Errorf("unpacking %s: %v", key, err)
  1857  			}
  1858  			obj.ObjectSelector = v.Value
  1859  			continue
  1860  		}
  1861  		if key == "path" {
  1862  			v, ok := starlark.AsString(val)
  1863  			if !ok {
  1864  				return fmt.Errorf("Expected string, actual: %s", val.Type())
  1865  			}
  1866  			obj.Path = string(v)
  1867  			continue
  1868  		}
  1869  		if key == "object" {
  1870  			v := KubernetesImageObjectDescriptor{t: o.t}
  1871  			err := v.Unpack(val)
  1872  			if err != nil {
  1873  				return fmt.Errorf("unpacking %s: %v", key, err)
  1874  			}
  1875  			obj.Object = (*v1alpha1.KubernetesImageObjectDescriptor)(&v.Value)
  1876  			continue
  1877  		}
  1878  		return fmt.Errorf("Unexpected attribute name: %s", key)
  1879  	}
  1880  
  1881  	mapObj.Freeze()
  1882  	o.Dict = mapObj
  1883  	o.Value = obj
  1884  	o.isUnpacked = true
  1885  
  1886  	return nil
  1887  }
  1888  
  1889  type KubernetesImageLocatorList struct {
  1890  	*starlark.List
  1891  	Value []v1alpha1.KubernetesImageLocator
  1892  	t     *starlark.Thread
  1893  }
  1894  
  1895  func (o *KubernetesImageLocatorList) Unpack(v starlark.Value) error {
  1896  	items := []v1alpha1.KubernetesImageLocator{}
  1897  
  1898  	listObj, ok := v.(*starlark.List)
  1899  	if !ok {
  1900  		return fmt.Errorf("expected list, actual: %v", v.Type())
  1901  	}
  1902  
  1903  	for i := 0; i < listObj.Len(); i++ {
  1904  		v := listObj.Index(i)
  1905  
  1906  		item := KubernetesImageLocator{t: o.t}
  1907  		err := item.Unpack(v)
  1908  		if err != nil {
  1909  			return fmt.Errorf("at index %d: %v", i, err)
  1910  		}
  1911  		items = append(items, v1alpha1.KubernetesImageLocator(item.Value))
  1912  	}
  1913  
  1914  	listObj.Freeze()
  1915  	o.List = listObj
  1916  	o.Value = items
  1917  
  1918  	return nil
  1919  }
  1920  
  1921  type KubernetesImageObjectDescriptor struct {
  1922  	*starlark.Dict
  1923  	Value      v1alpha1.KubernetesImageObjectDescriptor
  1924  	isUnpacked bool
  1925  	t          *starlark.Thread // instantiation thread for computing abspath
  1926  }
  1927  
  1928  func (p Plugin) kubernetesImageObjectDescriptor(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  1929  	var repoField starlark.Value
  1930  	var tagField starlark.Value
  1931  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
  1932  		"repo_field?", &repoField,
  1933  		"tag_field?", &tagField,
  1934  	)
  1935  	if err != nil {
  1936  		return nil, err
  1937  	}
  1938  
  1939  	dict := starlark.NewDict(2)
  1940  
  1941  	if repoField != nil {
  1942  		err := dict.SetKey(starlark.String("repo_field"), repoField)
  1943  		if err != nil {
  1944  			return nil, err
  1945  		}
  1946  	}
  1947  	if tagField != nil {
  1948  		err := dict.SetKey(starlark.String("tag_field"), tagField)
  1949  		if err != nil {
  1950  			return nil, err
  1951  		}
  1952  	}
  1953  	var obj *KubernetesImageObjectDescriptor = &KubernetesImageObjectDescriptor{t: t}
  1954  	err = obj.Unpack(dict)
  1955  	if err != nil {
  1956  		return nil, err
  1957  	}
  1958  	return obj, nil
  1959  }
  1960  
  1961  func (o *KubernetesImageObjectDescriptor) Unpack(v starlark.Value) error {
  1962  	obj := v1alpha1.KubernetesImageObjectDescriptor{}
  1963  
  1964  	starlarkObj, ok := v.(*KubernetesImageObjectDescriptor)
  1965  	if ok {
  1966  		*o = *starlarkObj
  1967  		return nil
  1968  	}
  1969  
  1970  	mapObj, ok := v.(*starlark.Dict)
  1971  	if !ok {
  1972  		return fmt.Errorf("expected dict, actual: %v", v.Type())
  1973  	}
  1974  
  1975  	for _, item := range mapObj.Items() {
  1976  		keyV, val := item[0], item[1]
  1977  		key, ok := starlark.AsString(keyV)
  1978  		if !ok {
  1979  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
  1980  		}
  1981  
  1982  		if key == "repo_field" {
  1983  			v, ok := starlark.AsString(val)
  1984  			if !ok {
  1985  				return fmt.Errorf("Expected string, actual: %s", val.Type())
  1986  			}
  1987  			obj.RepoField = string(v)
  1988  			continue
  1989  		}
  1990  		if key == "tag_field" {
  1991  			v, ok := starlark.AsString(val)
  1992  			if !ok {
  1993  				return fmt.Errorf("Expected string, actual: %s", val.Type())
  1994  			}
  1995  			obj.TagField = string(v)
  1996  			continue
  1997  		}
  1998  		return fmt.Errorf("Unexpected attribute name: %s", key)
  1999  	}
  2000  
  2001  	mapObj.Freeze()
  2002  	o.Dict = mapObj
  2003  	o.Value = obj
  2004  	o.isUnpacked = true
  2005  
  2006  	return nil
  2007  }
  2008  
  2009  type KubernetesImageObjectDescriptorList struct {
  2010  	*starlark.List
  2011  	Value []v1alpha1.KubernetesImageObjectDescriptor
  2012  	t     *starlark.Thread
  2013  }
  2014  
  2015  func (o *KubernetesImageObjectDescriptorList) Unpack(v starlark.Value) error {
  2016  	items := []v1alpha1.KubernetesImageObjectDescriptor{}
  2017  
  2018  	listObj, ok := v.(*starlark.List)
  2019  	if !ok {
  2020  		return fmt.Errorf("expected list, actual: %v", v.Type())
  2021  	}
  2022  
  2023  	for i := 0; i < listObj.Len(); i++ {
  2024  		v := listObj.Index(i)
  2025  
  2026  		item := KubernetesImageObjectDescriptor{t: o.t}
  2027  		err := item.Unpack(v)
  2028  		if err != nil {
  2029  			return fmt.Errorf("at index %d: %v", i, err)
  2030  		}
  2031  		items = append(items, v1alpha1.KubernetesImageObjectDescriptor(item.Value))
  2032  	}
  2033  
  2034  	listObj.Freeze()
  2035  	o.List = listObj
  2036  	o.Value = items
  2037  
  2038  	return nil
  2039  }
  2040  
  2041  type KubernetesWatchRef struct {
  2042  	*starlark.Dict
  2043  	Value      v1alpha1.KubernetesWatchRef
  2044  	isUnpacked bool
  2045  	t          *starlark.Thread // instantiation thread for computing abspath
  2046  }
  2047  
  2048  func (p Plugin) kubernetesWatchRef(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  2049  	var uID starlark.Value
  2050  	var namespace starlark.Value
  2051  	var name starlark.Value
  2052  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
  2053  		"uid?", &uID,
  2054  		"namespace?", &namespace,
  2055  		"name?", &name,
  2056  	)
  2057  	if err != nil {
  2058  		return nil, err
  2059  	}
  2060  
  2061  	dict := starlark.NewDict(3)
  2062  
  2063  	if uID != nil {
  2064  		err := dict.SetKey(starlark.String("uid"), uID)
  2065  		if err != nil {
  2066  			return nil, err
  2067  		}
  2068  	}
  2069  	if namespace != nil {
  2070  		err := dict.SetKey(starlark.String("namespace"), namespace)
  2071  		if err != nil {
  2072  			return nil, err
  2073  		}
  2074  	}
  2075  	if name != nil {
  2076  		err := dict.SetKey(starlark.String("name"), name)
  2077  		if err != nil {
  2078  			return nil, err
  2079  		}
  2080  	}
  2081  	var obj *KubernetesWatchRef = &KubernetesWatchRef{t: t}
  2082  	err = obj.Unpack(dict)
  2083  	if err != nil {
  2084  		return nil, err
  2085  	}
  2086  	return obj, nil
  2087  }
  2088  
  2089  func (o *KubernetesWatchRef) Unpack(v starlark.Value) error {
  2090  	obj := v1alpha1.KubernetesWatchRef{}
  2091  
  2092  	starlarkObj, ok := v.(*KubernetesWatchRef)
  2093  	if ok {
  2094  		*o = *starlarkObj
  2095  		return nil
  2096  	}
  2097  
  2098  	mapObj, ok := v.(*starlark.Dict)
  2099  	if !ok {
  2100  		return fmt.Errorf("expected dict, actual: %v", v.Type())
  2101  	}
  2102  
  2103  	for _, item := range mapObj.Items() {
  2104  		keyV, val := item[0], item[1]
  2105  		key, ok := starlark.AsString(keyV)
  2106  		if !ok {
  2107  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
  2108  		}
  2109  
  2110  		if key == "uid" {
  2111  			v, ok := starlark.AsString(val)
  2112  			if !ok {
  2113  				return fmt.Errorf("Expected string, actual: %s", val.Type())
  2114  			}
  2115  			obj.UID = string(v)
  2116  			continue
  2117  		}
  2118  		if key == "namespace" {
  2119  			v, ok := starlark.AsString(val)
  2120  			if !ok {
  2121  				return fmt.Errorf("Expected string, actual: %s", val.Type())
  2122  			}
  2123  			obj.Namespace = string(v)
  2124  			continue
  2125  		}
  2126  		if key == "name" {
  2127  			v, ok := starlark.AsString(val)
  2128  			if !ok {
  2129  				return fmt.Errorf("Expected string, actual: %s", val.Type())
  2130  			}
  2131  			obj.Name = string(v)
  2132  			continue
  2133  		}
  2134  		return fmt.Errorf("Unexpected attribute name: %s", key)
  2135  	}
  2136  
  2137  	mapObj.Freeze()
  2138  	o.Dict = mapObj
  2139  	o.Value = obj
  2140  	o.isUnpacked = true
  2141  
  2142  	return nil
  2143  }
  2144  
  2145  type KubernetesWatchRefList struct {
  2146  	*starlark.List
  2147  	Value []v1alpha1.KubernetesWatchRef
  2148  	t     *starlark.Thread
  2149  }
  2150  
  2151  func (o *KubernetesWatchRefList) Unpack(v starlark.Value) error {
  2152  	items := []v1alpha1.KubernetesWatchRef{}
  2153  
  2154  	listObj, ok := v.(*starlark.List)
  2155  	if !ok {
  2156  		return fmt.Errorf("expected list, actual: %v", v.Type())
  2157  	}
  2158  
  2159  	for i := 0; i < listObj.Len(); i++ {
  2160  		v := listObj.Index(i)
  2161  
  2162  		item := KubernetesWatchRef{t: o.t}
  2163  		err := item.Unpack(v)
  2164  		if err != nil {
  2165  			return fmt.Errorf("at index %d: %v", i, err)
  2166  		}
  2167  		items = append(items, v1alpha1.KubernetesWatchRef(item.Value))
  2168  	}
  2169  
  2170  	listObj.Freeze()
  2171  	o.List = listObj
  2172  	o.Value = items
  2173  
  2174  	return nil
  2175  }
  2176  
  2177  type LabelSelector struct {
  2178  	*starlark.Dict
  2179  	Value      metav1.LabelSelector
  2180  	isUnpacked bool
  2181  	t          *starlark.Thread // instantiation thread for computing abspath
  2182  }
  2183  
  2184  func (p Plugin) labelSelector(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  2185  	var matchLabels starlark.Value
  2186  	var matchExpressions starlark.Value
  2187  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
  2188  		"match_labels?", &matchLabels,
  2189  		"match_expressions?", &matchExpressions,
  2190  	)
  2191  	if err != nil {
  2192  		return nil, err
  2193  	}
  2194  
  2195  	dict := starlark.NewDict(2)
  2196  
  2197  	if matchLabels != nil {
  2198  		err := dict.SetKey(starlark.String("match_labels"), matchLabels)
  2199  		if err != nil {
  2200  			return nil, err
  2201  		}
  2202  	}
  2203  	if matchExpressions != nil {
  2204  		err := dict.SetKey(starlark.String("match_expressions"), matchExpressions)
  2205  		if err != nil {
  2206  			return nil, err
  2207  		}
  2208  	}
  2209  	var obj *LabelSelector = &LabelSelector{t: t}
  2210  	err = obj.Unpack(dict)
  2211  	if err != nil {
  2212  		return nil, err
  2213  	}
  2214  	return obj, nil
  2215  }
  2216  
  2217  func (o *LabelSelector) Unpack(v starlark.Value) error {
  2218  	obj := metav1.LabelSelector{}
  2219  
  2220  	starlarkObj, ok := v.(*LabelSelector)
  2221  	if ok {
  2222  		*o = *starlarkObj
  2223  		return nil
  2224  	}
  2225  
  2226  	mapObj, ok := v.(*starlark.Dict)
  2227  	if !ok {
  2228  		return fmt.Errorf("expected dict, actual: %v", v.Type())
  2229  	}
  2230  
  2231  	for _, item := range mapObj.Items() {
  2232  		keyV, val := item[0], item[1]
  2233  		key, ok := starlark.AsString(keyV)
  2234  		if !ok {
  2235  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
  2236  		}
  2237  
  2238  		if key == "match_labels" {
  2239  			var v value.StringStringMap
  2240  			err := v.Unpack(val)
  2241  			if err != nil {
  2242  				return fmt.Errorf("unpacking %s: %v", key, err)
  2243  			}
  2244  			obj.MatchLabels = (map[string]string)(v)
  2245  			continue
  2246  		}
  2247  		if key == "match_expressions" {
  2248  			v := LabelSelectorRequirementList{t: o.t}
  2249  			err := v.Unpack(val)
  2250  			if err != nil {
  2251  				return fmt.Errorf("unpacking %s: %v", key, err)
  2252  			}
  2253  			obj.MatchExpressions = v.Value
  2254  			continue
  2255  		}
  2256  		return fmt.Errorf("Unexpected attribute name: %s", key)
  2257  	}
  2258  
  2259  	mapObj.Freeze()
  2260  	o.Dict = mapObj
  2261  	o.Value = obj
  2262  	o.isUnpacked = true
  2263  
  2264  	return nil
  2265  }
  2266  
  2267  type LabelSelectorList struct {
  2268  	*starlark.List
  2269  	Value []metav1.LabelSelector
  2270  	t     *starlark.Thread
  2271  }
  2272  
  2273  func (o *LabelSelectorList) Unpack(v starlark.Value) error {
  2274  	items := []metav1.LabelSelector{}
  2275  
  2276  	listObj, ok := v.(*starlark.List)
  2277  	if !ok {
  2278  		return fmt.Errorf("expected list, actual: %v", v.Type())
  2279  	}
  2280  
  2281  	for i := 0; i < listObj.Len(); i++ {
  2282  		v := listObj.Index(i)
  2283  
  2284  		item := LabelSelector{t: o.t}
  2285  		err := item.Unpack(v)
  2286  		if err != nil {
  2287  			return fmt.Errorf("at index %d: %v", i, err)
  2288  		}
  2289  		items = append(items, metav1.LabelSelector(item.Value))
  2290  	}
  2291  
  2292  	listObj.Freeze()
  2293  	o.List = listObj
  2294  	o.Value = items
  2295  
  2296  	return nil
  2297  }
  2298  
  2299  type LabelSelectorRequirement struct {
  2300  	*starlark.Dict
  2301  	Value      metav1.LabelSelectorRequirement
  2302  	isUnpacked bool
  2303  	t          *starlark.Thread // instantiation thread for computing abspath
  2304  }
  2305  
  2306  func (p Plugin) labelSelectorRequirement(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  2307  	var key starlark.Value
  2308  	var operator starlark.Value
  2309  	var values starlark.Value
  2310  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
  2311  		"key?", &key,
  2312  		"operator?", &operator,
  2313  		"values?", &values,
  2314  	)
  2315  	if err != nil {
  2316  		return nil, err
  2317  	}
  2318  
  2319  	dict := starlark.NewDict(3)
  2320  
  2321  	if key != nil {
  2322  		err := dict.SetKey(starlark.String("key"), key)
  2323  		if err != nil {
  2324  			return nil, err
  2325  		}
  2326  	}
  2327  	if operator != nil {
  2328  		err := dict.SetKey(starlark.String("operator"), operator)
  2329  		if err != nil {
  2330  			return nil, err
  2331  		}
  2332  	}
  2333  	if values != nil {
  2334  		err := dict.SetKey(starlark.String("values"), values)
  2335  		if err != nil {
  2336  			return nil, err
  2337  		}
  2338  	}
  2339  	var obj *LabelSelectorRequirement = &LabelSelectorRequirement{t: t}
  2340  	err = obj.Unpack(dict)
  2341  	if err != nil {
  2342  		return nil, err
  2343  	}
  2344  	return obj, nil
  2345  }
  2346  
  2347  func (o *LabelSelectorRequirement) Unpack(v starlark.Value) error {
  2348  	obj := metav1.LabelSelectorRequirement{}
  2349  
  2350  	starlarkObj, ok := v.(*LabelSelectorRequirement)
  2351  	if ok {
  2352  		*o = *starlarkObj
  2353  		return nil
  2354  	}
  2355  
  2356  	mapObj, ok := v.(*starlark.Dict)
  2357  	if !ok {
  2358  		return fmt.Errorf("expected dict, actual: %v", v.Type())
  2359  	}
  2360  
  2361  	for _, item := range mapObj.Items() {
  2362  		keyV, val := item[0], item[1]
  2363  		key, ok := starlark.AsString(keyV)
  2364  		if !ok {
  2365  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
  2366  		}
  2367  
  2368  		if key == "key" {
  2369  			v, ok := starlark.AsString(val)
  2370  			if !ok {
  2371  				return fmt.Errorf("Expected string, actual: %s", val.Type())
  2372  			}
  2373  			obj.Key = string(v)
  2374  			continue
  2375  		}
  2376  		if key == "operator" {
  2377  			v, ok := starlark.AsString(val)
  2378  			if !ok {
  2379  				return fmt.Errorf("Expected string, actual: %s", val.Type())
  2380  			}
  2381  			obj.Operator = metav1.LabelSelectorOperator(v)
  2382  			continue
  2383  		}
  2384  		if key == "values" {
  2385  			var v value.StringList
  2386  			err := v.Unpack(val)
  2387  			if err != nil {
  2388  				return fmt.Errorf("unpacking %s: %v", key, err)
  2389  			}
  2390  			obj.Values = v
  2391  			continue
  2392  		}
  2393  		return fmt.Errorf("Unexpected attribute name: %s", key)
  2394  	}
  2395  
  2396  	mapObj.Freeze()
  2397  	o.Dict = mapObj
  2398  	o.Value = obj
  2399  	o.isUnpacked = true
  2400  
  2401  	return nil
  2402  }
  2403  
  2404  type LabelSelectorRequirementList struct {
  2405  	*starlark.List
  2406  	Value []metav1.LabelSelectorRequirement
  2407  	t     *starlark.Thread
  2408  }
  2409  
  2410  func (o *LabelSelectorRequirementList) Unpack(v starlark.Value) error {
  2411  	items := []metav1.LabelSelectorRequirement{}
  2412  
  2413  	listObj, ok := v.(*starlark.List)
  2414  	if !ok {
  2415  		return fmt.Errorf("expected list, actual: %v", v.Type())
  2416  	}
  2417  
  2418  	for i := 0; i < listObj.Len(); i++ {
  2419  		v := listObj.Index(i)
  2420  
  2421  		item := LabelSelectorRequirement{t: o.t}
  2422  		err := item.Unpack(v)
  2423  		if err != nil {
  2424  			return fmt.Errorf("at index %d: %v", i, err)
  2425  		}
  2426  		items = append(items, metav1.LabelSelectorRequirement(item.Value))
  2427  	}
  2428  
  2429  	listObj.Freeze()
  2430  	o.List = listObj
  2431  	o.Value = items
  2432  
  2433  	return nil
  2434  }
  2435  
  2436  type ObjectSelector struct {
  2437  	*starlark.Dict
  2438  	Value      v1alpha1.ObjectSelector
  2439  	isUnpacked bool
  2440  	t          *starlark.Thread // instantiation thread for computing abspath
  2441  }
  2442  
  2443  func (p Plugin) objectSelector(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  2444  	var aPIVersionRegexp starlark.Value
  2445  	var kindRegexp starlark.Value
  2446  	var nameRegexp starlark.Value
  2447  	var namespaceRegexp starlark.Value
  2448  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
  2449  		"api_version_regexp?", &aPIVersionRegexp,
  2450  		"kind_regexp?", &kindRegexp,
  2451  		"name_regexp?", &nameRegexp,
  2452  		"namespace_regexp?", &namespaceRegexp,
  2453  	)
  2454  	if err != nil {
  2455  		return nil, err
  2456  	}
  2457  
  2458  	dict := starlark.NewDict(4)
  2459  
  2460  	if aPIVersionRegexp != nil {
  2461  		err := dict.SetKey(starlark.String("api_version_regexp"), aPIVersionRegexp)
  2462  		if err != nil {
  2463  			return nil, err
  2464  		}
  2465  	}
  2466  	if kindRegexp != nil {
  2467  		err := dict.SetKey(starlark.String("kind_regexp"), kindRegexp)
  2468  		if err != nil {
  2469  			return nil, err
  2470  		}
  2471  	}
  2472  	if nameRegexp != nil {
  2473  		err := dict.SetKey(starlark.String("name_regexp"), nameRegexp)
  2474  		if err != nil {
  2475  			return nil, err
  2476  		}
  2477  	}
  2478  	if namespaceRegexp != nil {
  2479  		err := dict.SetKey(starlark.String("namespace_regexp"), namespaceRegexp)
  2480  		if err != nil {
  2481  			return nil, err
  2482  		}
  2483  	}
  2484  	var obj *ObjectSelector = &ObjectSelector{t: t}
  2485  	err = obj.Unpack(dict)
  2486  	if err != nil {
  2487  		return nil, err
  2488  	}
  2489  	return obj, nil
  2490  }
  2491  
  2492  func (o *ObjectSelector) Unpack(v starlark.Value) error {
  2493  	obj := v1alpha1.ObjectSelector{}
  2494  
  2495  	starlarkObj, ok := v.(*ObjectSelector)
  2496  	if ok {
  2497  		*o = *starlarkObj
  2498  		return nil
  2499  	}
  2500  
  2501  	mapObj, ok := v.(*starlark.Dict)
  2502  	if !ok {
  2503  		return fmt.Errorf("expected dict, actual: %v", v.Type())
  2504  	}
  2505  
  2506  	for _, item := range mapObj.Items() {
  2507  		keyV, val := item[0], item[1]
  2508  		key, ok := starlark.AsString(keyV)
  2509  		if !ok {
  2510  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
  2511  		}
  2512  
  2513  		if key == "api_version_regexp" {
  2514  			v, ok := starlark.AsString(val)
  2515  			if !ok {
  2516  				return fmt.Errorf("Expected string, actual: %s", val.Type())
  2517  			}
  2518  			obj.APIVersionRegexp = string(v)
  2519  			continue
  2520  		}
  2521  		if key == "kind_regexp" {
  2522  			v, ok := starlark.AsString(val)
  2523  			if !ok {
  2524  				return fmt.Errorf("Expected string, actual: %s", val.Type())
  2525  			}
  2526  			obj.KindRegexp = string(v)
  2527  			continue
  2528  		}
  2529  		if key == "name_regexp" {
  2530  			v, ok := starlark.AsString(val)
  2531  			if !ok {
  2532  				return fmt.Errorf("Expected string, actual: %s", val.Type())
  2533  			}
  2534  			obj.NameRegexp = string(v)
  2535  			continue
  2536  		}
  2537  		if key == "namespace_regexp" {
  2538  			v, ok := starlark.AsString(val)
  2539  			if !ok {
  2540  				return fmt.Errorf("Expected string, actual: %s", val.Type())
  2541  			}
  2542  			obj.NamespaceRegexp = string(v)
  2543  			continue
  2544  		}
  2545  		return fmt.Errorf("Unexpected attribute name: %s", key)
  2546  	}
  2547  
  2548  	mapObj.Freeze()
  2549  	o.Dict = mapObj
  2550  	o.Value = obj
  2551  	o.isUnpacked = true
  2552  
  2553  	return nil
  2554  }
  2555  
  2556  type ObjectSelectorList struct {
  2557  	*starlark.List
  2558  	Value []v1alpha1.ObjectSelector
  2559  	t     *starlark.Thread
  2560  }
  2561  
  2562  func (o *ObjectSelectorList) Unpack(v starlark.Value) error {
  2563  	items := []v1alpha1.ObjectSelector{}
  2564  
  2565  	listObj, ok := v.(*starlark.List)
  2566  	if !ok {
  2567  		return fmt.Errorf("expected list, actual: %v", v.Type())
  2568  	}
  2569  
  2570  	for i := 0; i < listObj.Len(); i++ {
  2571  		v := listObj.Index(i)
  2572  
  2573  		item := ObjectSelector{t: o.t}
  2574  		err := item.Unpack(v)
  2575  		if err != nil {
  2576  			return fmt.Errorf("at index %d: %v", i, err)
  2577  		}
  2578  		items = append(items, v1alpha1.ObjectSelector(item.Value))
  2579  	}
  2580  
  2581  	listObj.Freeze()
  2582  	o.List = listObj
  2583  	o.Value = items
  2584  
  2585  	return nil
  2586  }
  2587  
  2588  type PodLogStreamTemplateSpec struct {
  2589  	*starlark.Dict
  2590  	Value      v1alpha1.PodLogStreamTemplateSpec
  2591  	isUnpacked bool
  2592  	t          *starlark.Thread // instantiation thread for computing abspath
  2593  }
  2594  
  2595  func (p Plugin) podLogStreamTemplateSpec(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  2596  	var sinceTime starlark.Value
  2597  	var onlyContainers starlark.Value
  2598  	var ignoreContainers starlark.Value
  2599  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
  2600  		"since_time?", &sinceTime,
  2601  		"only_containers?", &onlyContainers,
  2602  		"ignore_containers?", &ignoreContainers,
  2603  	)
  2604  	if err != nil {
  2605  		return nil, err
  2606  	}
  2607  
  2608  	dict := starlark.NewDict(3)
  2609  
  2610  	if sinceTime != nil {
  2611  		err := dict.SetKey(starlark.String("since_time"), sinceTime)
  2612  		if err != nil {
  2613  			return nil, err
  2614  		}
  2615  	}
  2616  	if onlyContainers != nil {
  2617  		err := dict.SetKey(starlark.String("only_containers"), onlyContainers)
  2618  		if err != nil {
  2619  			return nil, err
  2620  		}
  2621  	}
  2622  	if ignoreContainers != nil {
  2623  		err := dict.SetKey(starlark.String("ignore_containers"), ignoreContainers)
  2624  		if err != nil {
  2625  			return nil, err
  2626  		}
  2627  	}
  2628  	var obj *PodLogStreamTemplateSpec = &PodLogStreamTemplateSpec{t: t}
  2629  	err = obj.Unpack(dict)
  2630  	if err != nil {
  2631  		return nil, err
  2632  	}
  2633  	return obj, nil
  2634  }
  2635  
  2636  func (o *PodLogStreamTemplateSpec) Unpack(v starlark.Value) error {
  2637  	obj := v1alpha1.PodLogStreamTemplateSpec{}
  2638  
  2639  	starlarkObj, ok := v.(*PodLogStreamTemplateSpec)
  2640  	if ok {
  2641  		*o = *starlarkObj
  2642  		return nil
  2643  	}
  2644  
  2645  	mapObj, ok := v.(*starlark.Dict)
  2646  	if !ok {
  2647  		return fmt.Errorf("expected dict, actual: %v", v.Type())
  2648  	}
  2649  
  2650  	for _, item := range mapObj.Items() {
  2651  		keyV, val := item[0], item[1]
  2652  		key, ok := starlark.AsString(keyV)
  2653  		if !ok {
  2654  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
  2655  		}
  2656  
  2657  		if key == "only_containers" {
  2658  			var v value.StringList
  2659  			err := v.Unpack(val)
  2660  			if err != nil {
  2661  				return fmt.Errorf("unpacking %s: %v", key, err)
  2662  			}
  2663  			obj.OnlyContainers = v
  2664  			continue
  2665  		}
  2666  		if key == "ignore_containers" {
  2667  			var v value.StringList
  2668  			err := v.Unpack(val)
  2669  			if err != nil {
  2670  				return fmt.Errorf("unpacking %s: %v", key, err)
  2671  			}
  2672  			obj.IgnoreContainers = v
  2673  			continue
  2674  		}
  2675  		return fmt.Errorf("Unexpected attribute name: %s", key)
  2676  	}
  2677  
  2678  	mapObj.Freeze()
  2679  	o.Dict = mapObj
  2680  	o.Value = obj
  2681  	o.isUnpacked = true
  2682  
  2683  	return nil
  2684  }
  2685  
  2686  type PodLogStreamTemplateSpecList struct {
  2687  	*starlark.List
  2688  	Value []v1alpha1.PodLogStreamTemplateSpec
  2689  	t     *starlark.Thread
  2690  }
  2691  
  2692  func (o *PodLogStreamTemplateSpecList) Unpack(v starlark.Value) error {
  2693  	items := []v1alpha1.PodLogStreamTemplateSpec{}
  2694  
  2695  	listObj, ok := v.(*starlark.List)
  2696  	if !ok {
  2697  		return fmt.Errorf("expected list, actual: %v", v.Type())
  2698  	}
  2699  
  2700  	for i := 0; i < listObj.Len(); i++ {
  2701  		v := listObj.Index(i)
  2702  
  2703  		item := PodLogStreamTemplateSpec{t: o.t}
  2704  		err := item.Unpack(v)
  2705  		if err != nil {
  2706  			return fmt.Errorf("at index %d: %v", i, err)
  2707  		}
  2708  		items = append(items, v1alpha1.PodLogStreamTemplateSpec(item.Value))
  2709  	}
  2710  
  2711  	listObj.Freeze()
  2712  	o.List = listObj
  2713  	o.Value = items
  2714  
  2715  	return nil
  2716  }
  2717  
  2718  type PortForwardTemplateSpec struct {
  2719  	*starlark.Dict
  2720  	Value      v1alpha1.PortForwardTemplateSpec
  2721  	isUnpacked bool
  2722  	t          *starlark.Thread // instantiation thread for computing abspath
  2723  }
  2724  
  2725  func (p Plugin) portForwardTemplateSpec(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  2726  	var forwards starlark.Value
  2727  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
  2728  		"forwards?", &forwards,
  2729  	)
  2730  	if err != nil {
  2731  		return nil, err
  2732  	}
  2733  
  2734  	dict := starlark.NewDict(1)
  2735  
  2736  	if forwards != nil {
  2737  		err := dict.SetKey(starlark.String("forwards"), forwards)
  2738  		if err != nil {
  2739  			return nil, err
  2740  		}
  2741  	}
  2742  	var obj *PortForwardTemplateSpec = &PortForwardTemplateSpec{t: t}
  2743  	err = obj.Unpack(dict)
  2744  	if err != nil {
  2745  		return nil, err
  2746  	}
  2747  	return obj, nil
  2748  }
  2749  
  2750  func (o *PortForwardTemplateSpec) Unpack(v starlark.Value) error {
  2751  	obj := v1alpha1.PortForwardTemplateSpec{}
  2752  
  2753  	starlarkObj, ok := v.(*PortForwardTemplateSpec)
  2754  	if ok {
  2755  		*o = *starlarkObj
  2756  		return nil
  2757  	}
  2758  
  2759  	mapObj, ok := v.(*starlark.Dict)
  2760  	if !ok {
  2761  		return fmt.Errorf("expected dict, actual: %v", v.Type())
  2762  	}
  2763  
  2764  	for _, item := range mapObj.Items() {
  2765  		keyV, val := item[0], item[1]
  2766  		key, ok := starlark.AsString(keyV)
  2767  		if !ok {
  2768  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
  2769  		}
  2770  
  2771  		if key == "forwards" {
  2772  			v := ForwardList{t: o.t}
  2773  			err := v.Unpack(val)
  2774  			if err != nil {
  2775  				return fmt.Errorf("unpacking %s: %v", key, err)
  2776  			}
  2777  			obj.Forwards = v.Value
  2778  			continue
  2779  		}
  2780  		return fmt.Errorf("Unexpected attribute name: %s", key)
  2781  	}
  2782  
  2783  	mapObj.Freeze()
  2784  	o.Dict = mapObj
  2785  	o.Value = obj
  2786  	o.isUnpacked = true
  2787  
  2788  	return nil
  2789  }
  2790  
  2791  type PortForwardTemplateSpecList struct {
  2792  	*starlark.List
  2793  	Value []v1alpha1.PortForwardTemplateSpec
  2794  	t     *starlark.Thread
  2795  }
  2796  
  2797  func (o *PortForwardTemplateSpecList) Unpack(v starlark.Value) error {
  2798  	items := []v1alpha1.PortForwardTemplateSpec{}
  2799  
  2800  	listObj, ok := v.(*starlark.List)
  2801  	if !ok {
  2802  		return fmt.Errorf("expected list, actual: %v", v.Type())
  2803  	}
  2804  
  2805  	for i := 0; i < listObj.Len(); i++ {
  2806  		v := listObj.Index(i)
  2807  
  2808  		item := PortForwardTemplateSpec{t: o.t}
  2809  		err := item.Unpack(v)
  2810  		if err != nil {
  2811  			return fmt.Errorf("at index %d: %v", i, err)
  2812  		}
  2813  		items = append(items, v1alpha1.PortForwardTemplateSpec(item.Value))
  2814  	}
  2815  
  2816  	listObj.Freeze()
  2817  	o.List = listObj
  2818  	o.Value = items
  2819  
  2820  	return nil
  2821  }
  2822  
  2823  type Probe struct {
  2824  	*starlark.Dict
  2825  	Value      v1alpha1.Probe
  2826  	isUnpacked bool
  2827  	t          *starlark.Thread // instantiation thread for computing abspath
  2828  }
  2829  
  2830  func (p Plugin) probe(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  2831  	var handler starlark.Value
  2832  	var initialDelaySeconds starlark.Value
  2833  	var timeoutSeconds starlark.Value
  2834  	var periodSeconds starlark.Value
  2835  	var successThreshold starlark.Value
  2836  	var failureThreshold starlark.Value
  2837  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
  2838  		"handler?", &handler,
  2839  		"initial_delay_seconds?", &initialDelaySeconds,
  2840  		"timeout_seconds?", &timeoutSeconds,
  2841  		"period_seconds?", &periodSeconds,
  2842  		"success_threshold?", &successThreshold,
  2843  		"failure_threshold?", &failureThreshold,
  2844  	)
  2845  	if err != nil {
  2846  		return nil, err
  2847  	}
  2848  
  2849  	dict := starlark.NewDict(6)
  2850  
  2851  	if handler != nil {
  2852  		err := dict.SetKey(starlark.String("handler"), handler)
  2853  		if err != nil {
  2854  			return nil, err
  2855  		}
  2856  	}
  2857  	if initialDelaySeconds != nil {
  2858  		err := dict.SetKey(starlark.String("initial_delay_seconds"), initialDelaySeconds)
  2859  		if err != nil {
  2860  			return nil, err
  2861  		}
  2862  	}
  2863  	if timeoutSeconds != nil {
  2864  		err := dict.SetKey(starlark.String("timeout_seconds"), timeoutSeconds)
  2865  		if err != nil {
  2866  			return nil, err
  2867  		}
  2868  	}
  2869  	if periodSeconds != nil {
  2870  		err := dict.SetKey(starlark.String("period_seconds"), periodSeconds)
  2871  		if err != nil {
  2872  			return nil, err
  2873  		}
  2874  	}
  2875  	if successThreshold != nil {
  2876  		err := dict.SetKey(starlark.String("success_threshold"), successThreshold)
  2877  		if err != nil {
  2878  			return nil, err
  2879  		}
  2880  	}
  2881  	if failureThreshold != nil {
  2882  		err := dict.SetKey(starlark.String("failure_threshold"), failureThreshold)
  2883  		if err != nil {
  2884  			return nil, err
  2885  		}
  2886  	}
  2887  	var obj *Probe = &Probe{t: t}
  2888  	err = obj.Unpack(dict)
  2889  	if err != nil {
  2890  		return nil, err
  2891  	}
  2892  	return obj, nil
  2893  }
  2894  
  2895  func (o *Probe) Unpack(v starlark.Value) error {
  2896  	obj := v1alpha1.Probe{}
  2897  
  2898  	starlarkObj, ok := v.(*Probe)
  2899  	if ok {
  2900  		*o = *starlarkObj
  2901  		return nil
  2902  	}
  2903  
  2904  	mapObj, ok := v.(*starlark.Dict)
  2905  	if !ok {
  2906  		return fmt.Errorf("expected dict, actual: %v", v.Type())
  2907  	}
  2908  
  2909  	for _, item := range mapObj.Items() {
  2910  		keyV, val := item[0], item[1]
  2911  		key, ok := starlark.AsString(keyV)
  2912  		if !ok {
  2913  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
  2914  		}
  2915  
  2916  		if key == "exec" {
  2917  			v := ExecAction{t: o.t}
  2918  			err := v.Unpack(val)
  2919  			if err != nil {
  2920  				return fmt.Errorf("unpacking %s: %v", key, err)
  2921  			}
  2922  			obj.Exec = (*v1alpha1.ExecAction)(&v.Value)
  2923  			continue
  2924  		}
  2925  		if key == "http_get" {
  2926  			v := HTTPGetAction{t: o.t}
  2927  			err := v.Unpack(val)
  2928  			if err != nil {
  2929  				return fmt.Errorf("unpacking %s: %v", key, err)
  2930  			}
  2931  			obj.HTTPGet = (*v1alpha1.HTTPGetAction)(&v.Value)
  2932  			continue
  2933  		}
  2934  		if key == "tcp_socket" {
  2935  			v := TCPSocketAction{t: o.t}
  2936  			err := v.Unpack(val)
  2937  			if err != nil {
  2938  				return fmt.Errorf("unpacking %s: %v", key, err)
  2939  			}
  2940  			obj.TCPSocket = (*v1alpha1.TCPSocketAction)(&v.Value)
  2941  			continue
  2942  		}
  2943  		if key == "initial_delay_seconds" {
  2944  			v, err := starlark.AsInt32(val)
  2945  			if err != nil {
  2946  				return fmt.Errorf("Expected int, got: %v", err)
  2947  			}
  2948  			obj.InitialDelaySeconds = int32(v)
  2949  			continue
  2950  		}
  2951  		if key == "timeout_seconds" {
  2952  			v, err := starlark.AsInt32(val)
  2953  			if err != nil {
  2954  				return fmt.Errorf("Expected int, got: %v", err)
  2955  			}
  2956  			obj.TimeoutSeconds = int32(v)
  2957  			continue
  2958  		}
  2959  		if key == "period_seconds" {
  2960  			v, err := starlark.AsInt32(val)
  2961  			if err != nil {
  2962  				return fmt.Errorf("Expected int, got: %v", err)
  2963  			}
  2964  			obj.PeriodSeconds = int32(v)
  2965  			continue
  2966  		}
  2967  		if key == "success_threshold" {
  2968  			v, err := starlark.AsInt32(val)
  2969  			if err != nil {
  2970  				return fmt.Errorf("Expected int, got: %v", err)
  2971  			}
  2972  			obj.SuccessThreshold = int32(v)
  2973  			continue
  2974  		}
  2975  		if key == "failure_threshold" {
  2976  			v, err := starlark.AsInt32(val)
  2977  			if err != nil {
  2978  				return fmt.Errorf("Expected int, got: %v", err)
  2979  			}
  2980  			obj.FailureThreshold = int32(v)
  2981  			continue
  2982  		}
  2983  		return fmt.Errorf("Unexpected attribute name: %s", key)
  2984  	}
  2985  
  2986  	mapObj.Freeze()
  2987  	o.Dict = mapObj
  2988  	o.Value = obj
  2989  	o.isUnpacked = true
  2990  
  2991  	return nil
  2992  }
  2993  
  2994  type ProbeList struct {
  2995  	*starlark.List
  2996  	Value []v1alpha1.Probe
  2997  	t     *starlark.Thread
  2998  }
  2999  
  3000  func (o *ProbeList) Unpack(v starlark.Value) error {
  3001  	items := []v1alpha1.Probe{}
  3002  
  3003  	listObj, ok := v.(*starlark.List)
  3004  	if !ok {
  3005  		return fmt.Errorf("expected list, actual: %v", v.Type())
  3006  	}
  3007  
  3008  	for i := 0; i < listObj.Len(); i++ {
  3009  		v := listObj.Index(i)
  3010  
  3011  		item := Probe{t: o.t}
  3012  		err := item.Unpack(v)
  3013  		if err != nil {
  3014  			return fmt.Errorf("at index %d: %v", i, err)
  3015  		}
  3016  		items = append(items, v1alpha1.Probe(item.Value))
  3017  	}
  3018  
  3019  	listObj.Freeze()
  3020  	o.List = listObj
  3021  	o.Value = items
  3022  
  3023  	return nil
  3024  }
  3025  
  3026  type RestartOnSpec struct {
  3027  	*starlark.Dict
  3028  	Value      v1alpha1.RestartOnSpec
  3029  	isUnpacked bool
  3030  	t          *starlark.Thread // instantiation thread for computing abspath
  3031  }
  3032  
  3033  func (p Plugin) restartOnSpec(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  3034  	var fileWatches starlark.Value
  3035  	var uiButtons starlark.Value
  3036  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
  3037  		"file_watches?", &fileWatches,
  3038  		"ui_buttons?", &uiButtons,
  3039  	)
  3040  	if err != nil {
  3041  		return nil, err
  3042  	}
  3043  
  3044  	dict := starlark.NewDict(2)
  3045  
  3046  	if fileWatches != nil {
  3047  		err := dict.SetKey(starlark.String("file_watches"), fileWatches)
  3048  		if err != nil {
  3049  			return nil, err
  3050  		}
  3051  	}
  3052  	if uiButtons != nil {
  3053  		err := dict.SetKey(starlark.String("ui_buttons"), uiButtons)
  3054  		if err != nil {
  3055  			return nil, err
  3056  		}
  3057  	}
  3058  	var obj *RestartOnSpec = &RestartOnSpec{t: t}
  3059  	err = obj.Unpack(dict)
  3060  	if err != nil {
  3061  		return nil, err
  3062  	}
  3063  	return obj, nil
  3064  }
  3065  
  3066  func (o *RestartOnSpec) Unpack(v starlark.Value) error {
  3067  	obj := v1alpha1.RestartOnSpec{}
  3068  
  3069  	starlarkObj, ok := v.(*RestartOnSpec)
  3070  	if ok {
  3071  		*o = *starlarkObj
  3072  		return nil
  3073  	}
  3074  
  3075  	mapObj, ok := v.(*starlark.Dict)
  3076  	if !ok {
  3077  		return fmt.Errorf("expected dict, actual: %v", v.Type())
  3078  	}
  3079  
  3080  	for _, item := range mapObj.Items() {
  3081  		keyV, val := item[0], item[1]
  3082  		key, ok := starlark.AsString(keyV)
  3083  		if !ok {
  3084  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
  3085  		}
  3086  
  3087  		if key == "file_watches" {
  3088  			var v value.StringList
  3089  			err := v.Unpack(val)
  3090  			if err != nil {
  3091  				return fmt.Errorf("unpacking %s: %v", key, err)
  3092  			}
  3093  			obj.FileWatches = v
  3094  			continue
  3095  		}
  3096  		if key == "ui_buttons" {
  3097  			var v value.StringList
  3098  			err := v.Unpack(val)
  3099  			if err != nil {
  3100  				return fmt.Errorf("unpacking %s: %v", key, err)
  3101  			}
  3102  			obj.UIButtons = v
  3103  			continue
  3104  		}
  3105  		return fmt.Errorf("Unexpected attribute name: %s", key)
  3106  	}
  3107  
  3108  	mapObj.Freeze()
  3109  	o.Dict = mapObj
  3110  	o.Value = obj
  3111  	o.isUnpacked = true
  3112  
  3113  	return nil
  3114  }
  3115  
  3116  type RestartOnSpecList struct {
  3117  	*starlark.List
  3118  	Value []v1alpha1.RestartOnSpec
  3119  	t     *starlark.Thread
  3120  }
  3121  
  3122  func (o *RestartOnSpecList) Unpack(v starlark.Value) error {
  3123  	items := []v1alpha1.RestartOnSpec{}
  3124  
  3125  	listObj, ok := v.(*starlark.List)
  3126  	if !ok {
  3127  		return fmt.Errorf("expected list, actual: %v", v.Type())
  3128  	}
  3129  
  3130  	for i := 0; i < listObj.Len(); i++ {
  3131  		v := listObj.Index(i)
  3132  
  3133  		item := RestartOnSpec{t: o.t}
  3134  		err := item.Unpack(v)
  3135  		if err != nil {
  3136  			return fmt.Errorf("at index %d: %v", i, err)
  3137  		}
  3138  		items = append(items, v1alpha1.RestartOnSpec(item.Value))
  3139  	}
  3140  
  3141  	listObj.Freeze()
  3142  	o.List = listObj
  3143  	o.Value = items
  3144  
  3145  	return nil
  3146  }
  3147  
  3148  type StartOnSpec struct {
  3149  	*starlark.Dict
  3150  	Value      v1alpha1.StartOnSpec
  3151  	isUnpacked bool
  3152  	t          *starlark.Thread // instantiation thread for computing abspath
  3153  }
  3154  
  3155  func (p Plugin) startOnSpec(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  3156  	var startAfter starlark.Value
  3157  	var uiButtons starlark.Value
  3158  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
  3159  		"start_after?", &startAfter,
  3160  		"ui_buttons?", &uiButtons,
  3161  	)
  3162  	if err != nil {
  3163  		return nil, err
  3164  	}
  3165  
  3166  	dict := starlark.NewDict(2)
  3167  
  3168  	if startAfter != nil {
  3169  		err := dict.SetKey(starlark.String("start_after"), startAfter)
  3170  		if err != nil {
  3171  			return nil, err
  3172  		}
  3173  	}
  3174  	if uiButtons != nil {
  3175  		err := dict.SetKey(starlark.String("ui_buttons"), uiButtons)
  3176  		if err != nil {
  3177  			return nil, err
  3178  		}
  3179  	}
  3180  	var obj *StartOnSpec = &StartOnSpec{t: t}
  3181  	err = obj.Unpack(dict)
  3182  	if err != nil {
  3183  		return nil, err
  3184  	}
  3185  	return obj, nil
  3186  }
  3187  
  3188  func (o *StartOnSpec) Unpack(v starlark.Value) error {
  3189  	obj := v1alpha1.StartOnSpec{}
  3190  
  3191  	starlarkObj, ok := v.(*StartOnSpec)
  3192  	if ok {
  3193  		*o = *starlarkObj
  3194  		return nil
  3195  	}
  3196  
  3197  	mapObj, ok := v.(*starlark.Dict)
  3198  	if !ok {
  3199  		return fmt.Errorf("expected dict, actual: %v", v.Type())
  3200  	}
  3201  
  3202  	for _, item := range mapObj.Items() {
  3203  		keyV, val := item[0], item[1]
  3204  		key, ok := starlark.AsString(keyV)
  3205  		if !ok {
  3206  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
  3207  		}
  3208  
  3209  		if key == "ui_buttons" {
  3210  			var v value.StringList
  3211  			err := v.Unpack(val)
  3212  			if err != nil {
  3213  				return fmt.Errorf("unpacking %s: %v", key, err)
  3214  			}
  3215  			obj.UIButtons = v
  3216  			continue
  3217  		}
  3218  		return fmt.Errorf("Unexpected attribute name: %s", key)
  3219  	}
  3220  
  3221  	mapObj.Freeze()
  3222  	o.Dict = mapObj
  3223  	o.Value = obj
  3224  	o.isUnpacked = true
  3225  
  3226  	return nil
  3227  }
  3228  
  3229  type StartOnSpecList struct {
  3230  	*starlark.List
  3231  	Value []v1alpha1.StartOnSpec
  3232  	t     *starlark.Thread
  3233  }
  3234  
  3235  func (o *StartOnSpecList) Unpack(v starlark.Value) error {
  3236  	items := []v1alpha1.StartOnSpec{}
  3237  
  3238  	listObj, ok := v.(*starlark.List)
  3239  	if !ok {
  3240  		return fmt.Errorf("expected list, actual: %v", v.Type())
  3241  	}
  3242  
  3243  	for i := 0; i < listObj.Len(); i++ {
  3244  		v := listObj.Index(i)
  3245  
  3246  		item := StartOnSpec{t: o.t}
  3247  		err := item.Unpack(v)
  3248  		if err != nil {
  3249  			return fmt.Errorf("at index %d: %v", i, err)
  3250  		}
  3251  		items = append(items, v1alpha1.StartOnSpec(item.Value))
  3252  	}
  3253  
  3254  	listObj.Freeze()
  3255  	o.List = listObj
  3256  	o.Value = items
  3257  
  3258  	return nil
  3259  }
  3260  
  3261  type TCPSocketAction struct {
  3262  	*starlark.Dict
  3263  	Value      v1alpha1.TCPSocketAction
  3264  	isUnpacked bool
  3265  	t          *starlark.Thread // instantiation thread for computing abspath
  3266  }
  3267  
  3268  func (p Plugin) tCPSocketAction(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  3269  	var port starlark.Value
  3270  	var host starlark.Value
  3271  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
  3272  		"port?", &port,
  3273  		"host?", &host,
  3274  	)
  3275  	if err != nil {
  3276  		return nil, err
  3277  	}
  3278  
  3279  	dict := starlark.NewDict(2)
  3280  
  3281  	if port != nil {
  3282  		err := dict.SetKey(starlark.String("port"), port)
  3283  		if err != nil {
  3284  			return nil, err
  3285  		}
  3286  	}
  3287  	if host != nil {
  3288  		err := dict.SetKey(starlark.String("host"), host)
  3289  		if err != nil {
  3290  			return nil, err
  3291  		}
  3292  	}
  3293  	var obj *TCPSocketAction = &TCPSocketAction{t: t}
  3294  	err = obj.Unpack(dict)
  3295  	if err != nil {
  3296  		return nil, err
  3297  	}
  3298  	return obj, nil
  3299  }
  3300  
  3301  func (o *TCPSocketAction) Unpack(v starlark.Value) error {
  3302  	obj := v1alpha1.TCPSocketAction{}
  3303  
  3304  	starlarkObj, ok := v.(*TCPSocketAction)
  3305  	if ok {
  3306  		*o = *starlarkObj
  3307  		return nil
  3308  	}
  3309  
  3310  	mapObj, ok := v.(*starlark.Dict)
  3311  	if !ok {
  3312  		return fmt.Errorf("expected dict, actual: %v", v.Type())
  3313  	}
  3314  
  3315  	for _, item := range mapObj.Items() {
  3316  		keyV, val := item[0], item[1]
  3317  		key, ok := starlark.AsString(keyV)
  3318  		if !ok {
  3319  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
  3320  		}
  3321  
  3322  		if key == "port" {
  3323  			v, err := starlark.AsInt32(val)
  3324  			if err != nil {
  3325  				return fmt.Errorf("Expected int, got: %v", err)
  3326  			}
  3327  			obj.Port = int32(v)
  3328  			continue
  3329  		}
  3330  		if key == "host" {
  3331  			v, ok := starlark.AsString(val)
  3332  			if !ok {
  3333  				return fmt.Errorf("Expected string, actual: %s", val.Type())
  3334  			}
  3335  			obj.Host = string(v)
  3336  			continue
  3337  		}
  3338  		return fmt.Errorf("Unexpected attribute name: %s", key)
  3339  	}
  3340  
  3341  	mapObj.Freeze()
  3342  	o.Dict = mapObj
  3343  	o.Value = obj
  3344  	o.isUnpacked = true
  3345  
  3346  	return nil
  3347  }
  3348  
  3349  type TCPSocketActionList struct {
  3350  	*starlark.List
  3351  	Value []v1alpha1.TCPSocketAction
  3352  	t     *starlark.Thread
  3353  }
  3354  
  3355  func (o *TCPSocketActionList) Unpack(v starlark.Value) error {
  3356  	items := []v1alpha1.TCPSocketAction{}
  3357  
  3358  	listObj, ok := v.(*starlark.List)
  3359  	if !ok {
  3360  		return fmt.Errorf("expected list, actual: %v", v.Type())
  3361  	}
  3362  
  3363  	for i := 0; i < listObj.Len(); i++ {
  3364  		v := listObj.Index(i)
  3365  
  3366  		item := TCPSocketAction{t: o.t}
  3367  		err := item.Unpack(v)
  3368  		if err != nil {
  3369  			return fmt.Errorf("at index %d: %v", i, err)
  3370  		}
  3371  		items = append(items, v1alpha1.TCPSocketAction(item.Value))
  3372  	}
  3373  
  3374  	listObj.Freeze()
  3375  	o.List = listObj
  3376  	o.Value = items
  3377  
  3378  	return nil
  3379  }
  3380  
  3381  type UIBoolInputSpec struct {
  3382  	*starlark.Dict
  3383  	Value      v1alpha1.UIBoolInputSpec
  3384  	isUnpacked bool
  3385  	t          *starlark.Thread // instantiation thread for computing abspath
  3386  }
  3387  
  3388  func (p Plugin) uIBoolInputSpec(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  3389  	var defaultValue starlark.Value
  3390  	var trueString starlark.Value
  3391  	var falseString starlark.Value
  3392  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
  3393  		"default_value?", &defaultValue,
  3394  		"true_string?", &trueString,
  3395  		"false_string?", &falseString,
  3396  	)
  3397  	if err != nil {
  3398  		return nil, err
  3399  	}
  3400  
  3401  	dict := starlark.NewDict(3)
  3402  
  3403  	if defaultValue != nil {
  3404  		err := dict.SetKey(starlark.String("default_value"), defaultValue)
  3405  		if err != nil {
  3406  			return nil, err
  3407  		}
  3408  	}
  3409  	if trueString != nil {
  3410  		err := dict.SetKey(starlark.String("true_string"), trueString)
  3411  		if err != nil {
  3412  			return nil, err
  3413  		}
  3414  	}
  3415  	if falseString != nil {
  3416  		err := dict.SetKey(starlark.String("false_string"), falseString)
  3417  		if err != nil {
  3418  			return nil, err
  3419  		}
  3420  	}
  3421  	var obj *UIBoolInputSpec = &UIBoolInputSpec{t: t}
  3422  	err = obj.Unpack(dict)
  3423  	if err != nil {
  3424  		return nil, err
  3425  	}
  3426  	return obj, nil
  3427  }
  3428  
  3429  func (o *UIBoolInputSpec) Unpack(v starlark.Value) error {
  3430  	obj := v1alpha1.UIBoolInputSpec{}
  3431  
  3432  	starlarkObj, ok := v.(*UIBoolInputSpec)
  3433  	if ok {
  3434  		*o = *starlarkObj
  3435  		return nil
  3436  	}
  3437  
  3438  	mapObj, ok := v.(*starlark.Dict)
  3439  	if !ok {
  3440  		return fmt.Errorf("expected dict, actual: %v", v.Type())
  3441  	}
  3442  
  3443  	for _, item := range mapObj.Items() {
  3444  		keyV, val := item[0], item[1]
  3445  		key, ok := starlark.AsString(keyV)
  3446  		if !ok {
  3447  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
  3448  		}
  3449  
  3450  		if key == "default_value" {
  3451  			v, ok := val.(starlark.Bool)
  3452  			if !ok {
  3453  				return fmt.Errorf("Expected bool, got: %v", val.Type())
  3454  			}
  3455  			obj.DefaultValue = bool(v)
  3456  			continue
  3457  		}
  3458  		if key == "true_string" {
  3459  			v, ok := starlark.AsString(val)
  3460  			if !ok {
  3461  				return fmt.Errorf("Expected string, actual: %s", val.Type())
  3462  			}
  3463  			obj.TrueString = (*string)(&v)
  3464  			continue
  3465  		}
  3466  		if key == "false_string" {
  3467  			v, ok := starlark.AsString(val)
  3468  			if !ok {
  3469  				return fmt.Errorf("Expected string, actual: %s", val.Type())
  3470  			}
  3471  			obj.FalseString = (*string)(&v)
  3472  			continue
  3473  		}
  3474  		return fmt.Errorf("Unexpected attribute name: %s", key)
  3475  	}
  3476  
  3477  	mapObj.Freeze()
  3478  	o.Dict = mapObj
  3479  	o.Value = obj
  3480  	o.isUnpacked = true
  3481  
  3482  	return nil
  3483  }
  3484  
  3485  type UIBoolInputSpecList struct {
  3486  	*starlark.List
  3487  	Value []v1alpha1.UIBoolInputSpec
  3488  	t     *starlark.Thread
  3489  }
  3490  
  3491  func (o *UIBoolInputSpecList) Unpack(v starlark.Value) error {
  3492  	items := []v1alpha1.UIBoolInputSpec{}
  3493  
  3494  	listObj, ok := v.(*starlark.List)
  3495  	if !ok {
  3496  		return fmt.Errorf("expected list, actual: %v", v.Type())
  3497  	}
  3498  
  3499  	for i := 0; i < listObj.Len(); i++ {
  3500  		v := listObj.Index(i)
  3501  
  3502  		item := UIBoolInputSpec{t: o.t}
  3503  		err := item.Unpack(v)
  3504  		if err != nil {
  3505  			return fmt.Errorf("at index %d: %v", i, err)
  3506  		}
  3507  		items = append(items, v1alpha1.UIBoolInputSpec(item.Value))
  3508  	}
  3509  
  3510  	listObj.Freeze()
  3511  	o.List = listObj
  3512  	o.Value = items
  3513  
  3514  	return nil
  3515  }
  3516  
  3517  type UIChoiceInputSpec struct {
  3518  	*starlark.Dict
  3519  	Value      v1alpha1.UIChoiceInputSpec
  3520  	isUnpacked bool
  3521  	t          *starlark.Thread // instantiation thread for computing abspath
  3522  }
  3523  
  3524  func (p Plugin) uIChoiceInputSpec(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  3525  	var choices starlark.Value
  3526  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
  3527  		"choices?", &choices,
  3528  	)
  3529  	if err != nil {
  3530  		return nil, err
  3531  	}
  3532  
  3533  	dict := starlark.NewDict(1)
  3534  
  3535  	if choices != nil {
  3536  		err := dict.SetKey(starlark.String("choices"), choices)
  3537  		if err != nil {
  3538  			return nil, err
  3539  		}
  3540  	}
  3541  	var obj *UIChoiceInputSpec = &UIChoiceInputSpec{t: t}
  3542  	err = obj.Unpack(dict)
  3543  	if err != nil {
  3544  		return nil, err
  3545  	}
  3546  	return obj, nil
  3547  }
  3548  
  3549  func (o *UIChoiceInputSpec) Unpack(v starlark.Value) error {
  3550  	obj := v1alpha1.UIChoiceInputSpec{}
  3551  
  3552  	starlarkObj, ok := v.(*UIChoiceInputSpec)
  3553  	if ok {
  3554  		*o = *starlarkObj
  3555  		return nil
  3556  	}
  3557  
  3558  	mapObj, ok := v.(*starlark.Dict)
  3559  	if !ok {
  3560  		return fmt.Errorf("expected dict, actual: %v", v.Type())
  3561  	}
  3562  
  3563  	for _, item := range mapObj.Items() {
  3564  		keyV, val := item[0], item[1]
  3565  		key, ok := starlark.AsString(keyV)
  3566  		if !ok {
  3567  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
  3568  		}
  3569  
  3570  		if key == "choices" {
  3571  			var v value.StringList
  3572  			err := v.Unpack(val)
  3573  			if err != nil {
  3574  				return fmt.Errorf("unpacking %s: %v", key, err)
  3575  			}
  3576  			obj.Choices = v
  3577  			continue
  3578  		}
  3579  		return fmt.Errorf("Unexpected attribute name: %s", key)
  3580  	}
  3581  
  3582  	mapObj.Freeze()
  3583  	o.Dict = mapObj
  3584  	o.Value = obj
  3585  	o.isUnpacked = true
  3586  
  3587  	return nil
  3588  }
  3589  
  3590  type UIChoiceInputSpecList struct {
  3591  	*starlark.List
  3592  	Value []v1alpha1.UIChoiceInputSpec
  3593  	t     *starlark.Thread
  3594  }
  3595  
  3596  func (o *UIChoiceInputSpecList) Unpack(v starlark.Value) error {
  3597  	items := []v1alpha1.UIChoiceInputSpec{}
  3598  
  3599  	listObj, ok := v.(*starlark.List)
  3600  	if !ok {
  3601  		return fmt.Errorf("expected list, actual: %v", v.Type())
  3602  	}
  3603  
  3604  	for i := 0; i < listObj.Len(); i++ {
  3605  		v := listObj.Index(i)
  3606  
  3607  		item := UIChoiceInputSpec{t: o.t}
  3608  		err := item.Unpack(v)
  3609  		if err != nil {
  3610  			return fmt.Errorf("at index %d: %v", i, err)
  3611  		}
  3612  		items = append(items, v1alpha1.UIChoiceInputSpec(item.Value))
  3613  	}
  3614  
  3615  	listObj.Freeze()
  3616  	o.List = listObj
  3617  	o.Value = items
  3618  
  3619  	return nil
  3620  }
  3621  
  3622  type UIComponentLocation struct {
  3623  	*starlark.Dict
  3624  	Value      v1alpha1.UIComponentLocation
  3625  	isUnpacked bool
  3626  	t          *starlark.Thread // instantiation thread for computing abspath
  3627  }
  3628  
  3629  func (p Plugin) uIComponentLocation(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  3630  	var componentID starlark.Value
  3631  	var componentType starlark.Value
  3632  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
  3633  		"component_id?", &componentID,
  3634  		"component_type?", &componentType,
  3635  	)
  3636  	if err != nil {
  3637  		return nil, err
  3638  	}
  3639  
  3640  	dict := starlark.NewDict(2)
  3641  
  3642  	if componentID != nil {
  3643  		err := dict.SetKey(starlark.String("component_id"), componentID)
  3644  		if err != nil {
  3645  			return nil, err
  3646  		}
  3647  	}
  3648  	if componentType != nil {
  3649  		err := dict.SetKey(starlark.String("component_type"), componentType)
  3650  		if err != nil {
  3651  			return nil, err
  3652  		}
  3653  	}
  3654  	var obj *UIComponentLocation = &UIComponentLocation{t: t}
  3655  	err = obj.Unpack(dict)
  3656  	if err != nil {
  3657  		return nil, err
  3658  	}
  3659  	return obj, nil
  3660  }
  3661  
  3662  func (o *UIComponentLocation) Unpack(v starlark.Value) error {
  3663  	obj := v1alpha1.UIComponentLocation{}
  3664  
  3665  	starlarkObj, ok := v.(*UIComponentLocation)
  3666  	if ok {
  3667  		*o = *starlarkObj
  3668  		return nil
  3669  	}
  3670  
  3671  	mapObj, ok := v.(*starlark.Dict)
  3672  	if !ok {
  3673  		return fmt.Errorf("expected dict, actual: %v", v.Type())
  3674  	}
  3675  
  3676  	for _, item := range mapObj.Items() {
  3677  		keyV, val := item[0], item[1]
  3678  		key, ok := starlark.AsString(keyV)
  3679  		if !ok {
  3680  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
  3681  		}
  3682  
  3683  		if key == "component_id" {
  3684  			v, ok := starlark.AsString(val)
  3685  			if !ok {
  3686  				return fmt.Errorf("Expected string, actual: %s", val.Type())
  3687  			}
  3688  			obj.ComponentID = string(v)
  3689  			continue
  3690  		}
  3691  		if key == "component_type" {
  3692  			v, ok := starlark.AsString(val)
  3693  			if !ok {
  3694  				return fmt.Errorf("Expected string, actual: %s", val.Type())
  3695  			}
  3696  			obj.ComponentType = v1alpha1.ComponentType(v)
  3697  			continue
  3698  		}
  3699  		return fmt.Errorf("Unexpected attribute name: %s", key)
  3700  	}
  3701  
  3702  	mapObj.Freeze()
  3703  	o.Dict = mapObj
  3704  	o.Value = obj
  3705  	o.isUnpacked = true
  3706  
  3707  	return nil
  3708  }
  3709  
  3710  type UIComponentLocationList struct {
  3711  	*starlark.List
  3712  	Value []v1alpha1.UIComponentLocation
  3713  	t     *starlark.Thread
  3714  }
  3715  
  3716  func (o *UIComponentLocationList) Unpack(v starlark.Value) error {
  3717  	items := []v1alpha1.UIComponentLocation{}
  3718  
  3719  	listObj, ok := v.(*starlark.List)
  3720  	if !ok {
  3721  		return fmt.Errorf("expected list, actual: %v", v.Type())
  3722  	}
  3723  
  3724  	for i := 0; i < listObj.Len(); i++ {
  3725  		v := listObj.Index(i)
  3726  
  3727  		item := UIComponentLocation{t: o.t}
  3728  		err := item.Unpack(v)
  3729  		if err != nil {
  3730  			return fmt.Errorf("at index %d: %v", i, err)
  3731  		}
  3732  		items = append(items, v1alpha1.UIComponentLocation(item.Value))
  3733  	}
  3734  
  3735  	listObj.Freeze()
  3736  	o.List = listObj
  3737  	o.Value = items
  3738  
  3739  	return nil
  3740  }
  3741  
  3742  type UIHiddenInputSpec struct {
  3743  	*starlark.Dict
  3744  	Value      v1alpha1.UIHiddenInputSpec
  3745  	isUnpacked bool
  3746  	t          *starlark.Thread // instantiation thread for computing abspath
  3747  }
  3748  
  3749  func (p Plugin) uIHiddenInputSpec(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  3750  	var value starlark.Value
  3751  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
  3752  		"value?", &value,
  3753  	)
  3754  	if err != nil {
  3755  		return nil, err
  3756  	}
  3757  
  3758  	dict := starlark.NewDict(1)
  3759  
  3760  	if value != nil {
  3761  		err := dict.SetKey(starlark.String("value"), value)
  3762  		if err != nil {
  3763  			return nil, err
  3764  		}
  3765  	}
  3766  	var obj *UIHiddenInputSpec = &UIHiddenInputSpec{t: t}
  3767  	err = obj.Unpack(dict)
  3768  	if err != nil {
  3769  		return nil, err
  3770  	}
  3771  	return obj, nil
  3772  }
  3773  
  3774  func (o *UIHiddenInputSpec) Unpack(v starlark.Value) error {
  3775  	obj := v1alpha1.UIHiddenInputSpec{}
  3776  
  3777  	starlarkObj, ok := v.(*UIHiddenInputSpec)
  3778  	if ok {
  3779  		*o = *starlarkObj
  3780  		return nil
  3781  	}
  3782  
  3783  	mapObj, ok := v.(*starlark.Dict)
  3784  	if !ok {
  3785  		return fmt.Errorf("expected dict, actual: %v", v.Type())
  3786  	}
  3787  
  3788  	for _, item := range mapObj.Items() {
  3789  		keyV, val := item[0], item[1]
  3790  		key, ok := starlark.AsString(keyV)
  3791  		if !ok {
  3792  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
  3793  		}
  3794  
  3795  		if key == "value" {
  3796  			v, ok := starlark.AsString(val)
  3797  			if !ok {
  3798  				return fmt.Errorf("Expected string, actual: %s", val.Type())
  3799  			}
  3800  			obj.Value = string(v)
  3801  			continue
  3802  		}
  3803  		return fmt.Errorf("Unexpected attribute name: %s", key)
  3804  	}
  3805  
  3806  	mapObj.Freeze()
  3807  	o.Dict = mapObj
  3808  	o.Value = obj
  3809  	o.isUnpacked = true
  3810  
  3811  	return nil
  3812  }
  3813  
  3814  type UIHiddenInputSpecList struct {
  3815  	*starlark.List
  3816  	Value []v1alpha1.UIHiddenInputSpec
  3817  	t     *starlark.Thread
  3818  }
  3819  
  3820  func (o *UIHiddenInputSpecList) Unpack(v starlark.Value) error {
  3821  	items := []v1alpha1.UIHiddenInputSpec{}
  3822  
  3823  	listObj, ok := v.(*starlark.List)
  3824  	if !ok {
  3825  		return fmt.Errorf("expected list, actual: %v", v.Type())
  3826  	}
  3827  
  3828  	for i := 0; i < listObj.Len(); i++ {
  3829  		v := listObj.Index(i)
  3830  
  3831  		item := UIHiddenInputSpec{t: o.t}
  3832  		err := item.Unpack(v)
  3833  		if err != nil {
  3834  			return fmt.Errorf("at index %d: %v", i, err)
  3835  		}
  3836  		items = append(items, v1alpha1.UIHiddenInputSpec(item.Value))
  3837  	}
  3838  
  3839  	listObj.Freeze()
  3840  	o.List = listObj
  3841  	o.Value = items
  3842  
  3843  	return nil
  3844  }
  3845  
  3846  type UIInputSpec struct {
  3847  	*starlark.Dict
  3848  	Value      v1alpha1.UIInputSpec
  3849  	isUnpacked bool
  3850  	t          *starlark.Thread // instantiation thread for computing abspath
  3851  }
  3852  
  3853  func (p Plugin) uIInputSpec(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  3854  	var name starlark.Value
  3855  	var label starlark.Value
  3856  	var text starlark.Value
  3857  	var bool starlark.Value
  3858  	var hidden starlark.Value
  3859  	var choice starlark.Value
  3860  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
  3861  		"name?", &name,
  3862  		"label?", &label,
  3863  		"text?", &text,
  3864  		"bool?", &bool,
  3865  		"hidden?", &hidden,
  3866  		"choice?", &choice,
  3867  	)
  3868  	if err != nil {
  3869  		return nil, err
  3870  	}
  3871  
  3872  	dict := starlark.NewDict(6)
  3873  
  3874  	if name != nil {
  3875  		err := dict.SetKey(starlark.String("name"), name)
  3876  		if err != nil {
  3877  			return nil, err
  3878  		}
  3879  	}
  3880  	if label != nil {
  3881  		err := dict.SetKey(starlark.String("label"), label)
  3882  		if err != nil {
  3883  			return nil, err
  3884  		}
  3885  	}
  3886  	if text != nil {
  3887  		err := dict.SetKey(starlark.String("text"), text)
  3888  		if err != nil {
  3889  			return nil, err
  3890  		}
  3891  	}
  3892  	if bool != nil {
  3893  		err := dict.SetKey(starlark.String("bool"), bool)
  3894  		if err != nil {
  3895  			return nil, err
  3896  		}
  3897  	}
  3898  	if hidden != nil {
  3899  		err := dict.SetKey(starlark.String("hidden"), hidden)
  3900  		if err != nil {
  3901  			return nil, err
  3902  		}
  3903  	}
  3904  	if choice != nil {
  3905  		err := dict.SetKey(starlark.String("choice"), choice)
  3906  		if err != nil {
  3907  			return nil, err
  3908  		}
  3909  	}
  3910  	var obj *UIInputSpec = &UIInputSpec{t: t}
  3911  	err = obj.Unpack(dict)
  3912  	if err != nil {
  3913  		return nil, err
  3914  	}
  3915  	return obj, nil
  3916  }
  3917  
  3918  func (o *UIInputSpec) Unpack(v starlark.Value) error {
  3919  	obj := v1alpha1.UIInputSpec{}
  3920  
  3921  	starlarkObj, ok := v.(*UIInputSpec)
  3922  	if ok {
  3923  		*o = *starlarkObj
  3924  		return nil
  3925  	}
  3926  
  3927  	mapObj, ok := v.(*starlark.Dict)
  3928  	if !ok {
  3929  		return fmt.Errorf("expected dict, actual: %v", v.Type())
  3930  	}
  3931  
  3932  	for _, item := range mapObj.Items() {
  3933  		keyV, val := item[0], item[1]
  3934  		key, ok := starlark.AsString(keyV)
  3935  		if !ok {
  3936  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
  3937  		}
  3938  
  3939  		if key == "name" {
  3940  			v, ok := starlark.AsString(val)
  3941  			if !ok {
  3942  				return fmt.Errorf("Expected string, actual: %s", val.Type())
  3943  			}
  3944  			obj.Name = string(v)
  3945  			continue
  3946  		}
  3947  		if key == "label" {
  3948  			v, ok := starlark.AsString(val)
  3949  			if !ok {
  3950  				return fmt.Errorf("Expected string, actual: %s", val.Type())
  3951  			}
  3952  			obj.Label = string(v)
  3953  			continue
  3954  		}
  3955  		if key == "text" {
  3956  			v := UITextInputSpec{t: o.t}
  3957  			err := v.Unpack(val)
  3958  			if err != nil {
  3959  				return fmt.Errorf("unpacking %s: %v", key, err)
  3960  			}
  3961  			obj.Text = (*v1alpha1.UITextInputSpec)(&v.Value)
  3962  			continue
  3963  		}
  3964  		if key == "bool" {
  3965  			v := UIBoolInputSpec{t: o.t}
  3966  			err := v.Unpack(val)
  3967  			if err != nil {
  3968  				return fmt.Errorf("unpacking %s: %v", key, err)
  3969  			}
  3970  			obj.Bool = (*v1alpha1.UIBoolInputSpec)(&v.Value)
  3971  			continue
  3972  		}
  3973  		if key == "hidden" {
  3974  			v := UIHiddenInputSpec{t: o.t}
  3975  			err := v.Unpack(val)
  3976  			if err != nil {
  3977  				return fmt.Errorf("unpacking %s: %v", key, err)
  3978  			}
  3979  			obj.Hidden = (*v1alpha1.UIHiddenInputSpec)(&v.Value)
  3980  			continue
  3981  		}
  3982  		if key == "choice" {
  3983  			v := UIChoiceInputSpec{t: o.t}
  3984  			err := v.Unpack(val)
  3985  			if err != nil {
  3986  				return fmt.Errorf("unpacking %s: %v", key, err)
  3987  			}
  3988  			obj.Choice = (*v1alpha1.UIChoiceInputSpec)(&v.Value)
  3989  			continue
  3990  		}
  3991  		return fmt.Errorf("Unexpected attribute name: %s", key)
  3992  	}
  3993  
  3994  	mapObj.Freeze()
  3995  	o.Dict = mapObj
  3996  	o.Value = obj
  3997  	o.isUnpacked = true
  3998  
  3999  	return nil
  4000  }
  4001  
  4002  type UIInputSpecList struct {
  4003  	*starlark.List
  4004  	Value []v1alpha1.UIInputSpec
  4005  	t     *starlark.Thread
  4006  }
  4007  
  4008  func (o *UIInputSpecList) Unpack(v starlark.Value) error {
  4009  	items := []v1alpha1.UIInputSpec{}
  4010  
  4011  	listObj, ok := v.(*starlark.List)
  4012  	if !ok {
  4013  		return fmt.Errorf("expected list, actual: %v", v.Type())
  4014  	}
  4015  
  4016  	for i := 0; i < listObj.Len(); i++ {
  4017  		v := listObj.Index(i)
  4018  
  4019  		item := UIInputSpec{t: o.t}
  4020  		err := item.Unpack(v)
  4021  		if err != nil {
  4022  			return fmt.Errorf("at index %d: %v", i, err)
  4023  		}
  4024  		items = append(items, v1alpha1.UIInputSpec(item.Value))
  4025  	}
  4026  
  4027  	listObj.Freeze()
  4028  	o.List = listObj
  4029  	o.Value = items
  4030  
  4031  	return nil
  4032  }
  4033  
  4034  type UITextInputSpec struct {
  4035  	*starlark.Dict
  4036  	Value      v1alpha1.UITextInputSpec
  4037  	isUnpacked bool
  4038  	t          *starlark.Thread // instantiation thread for computing abspath
  4039  }
  4040  
  4041  func (p Plugin) uITextInputSpec(t *starlark.Thread, fn *starlark.Builtin, args starlark.Tuple, kwargs []starlark.Tuple) (starlark.Value, error) {
  4042  	var defaultValue starlark.Value
  4043  	var placeholder starlark.Value
  4044  	err := starkit.UnpackArgs(t, fn.Name(), args, kwargs,
  4045  		"default_value?", &defaultValue,
  4046  		"placeholder?", &placeholder,
  4047  	)
  4048  	if err != nil {
  4049  		return nil, err
  4050  	}
  4051  
  4052  	dict := starlark.NewDict(2)
  4053  
  4054  	if defaultValue != nil {
  4055  		err := dict.SetKey(starlark.String("default_value"), defaultValue)
  4056  		if err != nil {
  4057  			return nil, err
  4058  		}
  4059  	}
  4060  	if placeholder != nil {
  4061  		err := dict.SetKey(starlark.String("placeholder"), placeholder)
  4062  		if err != nil {
  4063  			return nil, err
  4064  		}
  4065  	}
  4066  	var obj *UITextInputSpec = &UITextInputSpec{t: t}
  4067  	err = obj.Unpack(dict)
  4068  	if err != nil {
  4069  		return nil, err
  4070  	}
  4071  	return obj, nil
  4072  }
  4073  
  4074  func (o *UITextInputSpec) Unpack(v starlark.Value) error {
  4075  	obj := v1alpha1.UITextInputSpec{}
  4076  
  4077  	starlarkObj, ok := v.(*UITextInputSpec)
  4078  	if ok {
  4079  		*o = *starlarkObj
  4080  		return nil
  4081  	}
  4082  
  4083  	mapObj, ok := v.(*starlark.Dict)
  4084  	if !ok {
  4085  		return fmt.Errorf("expected dict, actual: %v", v.Type())
  4086  	}
  4087  
  4088  	for _, item := range mapObj.Items() {
  4089  		keyV, val := item[0], item[1]
  4090  		key, ok := starlark.AsString(keyV)
  4091  		if !ok {
  4092  			return fmt.Errorf("key must be string. Got: %s", keyV.Type())
  4093  		}
  4094  
  4095  		if key == "default_value" {
  4096  			v, ok := starlark.AsString(val)
  4097  			if !ok {
  4098  				return fmt.Errorf("Expected string, actual: %s", val.Type())
  4099  			}
  4100  			obj.DefaultValue = string(v)
  4101  			continue
  4102  		}
  4103  		if key == "placeholder" {
  4104  			v, ok := starlark.AsString(val)
  4105  			if !ok {
  4106  				return fmt.Errorf("Expected string, actual: %s", val.Type())
  4107  			}
  4108  			obj.Placeholder = string(v)
  4109  			continue
  4110  		}
  4111  		return fmt.Errorf("Unexpected attribute name: %s", key)
  4112  	}
  4113  
  4114  	mapObj.Freeze()
  4115  	o.Dict = mapObj
  4116  	o.Value = obj
  4117  	o.isUnpacked = true
  4118  
  4119  	return nil
  4120  }
  4121  
  4122  type UITextInputSpecList struct {
  4123  	*starlark.List
  4124  	Value []v1alpha1.UITextInputSpec
  4125  	t     *starlark.Thread
  4126  }
  4127  
  4128  func (o *UITextInputSpecList) Unpack(v starlark.Value) error {
  4129  	items := []v1alpha1.UITextInputSpec{}
  4130  
  4131  	listObj, ok := v.(*starlark.List)
  4132  	if !ok {
  4133  		return fmt.Errorf("expected list, actual: %v", v.Type())
  4134  	}
  4135  
  4136  	for i := 0; i < listObj.Len(); i++ {
  4137  		v := listObj.Index(i)
  4138  
  4139  		item := UITextInputSpec{t: o.t}
  4140  		err := item.Unpack(v)
  4141  		if err != nil {
  4142  			return fmt.Errorf("at index %d: %v", i, err)
  4143  		}
  4144  		items = append(items, v1alpha1.UITextInputSpec(item.Value))
  4145  	}
  4146  
  4147  	listObj.Freeze()
  4148  	o.List = listObj
  4149  	o.Value = items
  4150  
  4151  	return nil
  4152  }