github.com/myhau/pulumi/pkg/v3@v3.70.2-0.20221116134521-f2775972e587/codegen/testing/test/testdata/output-funcs/python/pulumi_mypkg/outputs.py (about)

     1  # coding=utf-8
     2  # *** WARNING: this file was generated by test. ***
     3  # *** Do not edit by hand unless you're certain you know what you are doing! ***
     4  
     5  import copy
     6  import warnings
     7  import pulumi
     8  import pulumi.runtime
     9  from typing import Any, Mapping, Optional, Sequence, Union, overload
    10  from . import _utilities
    11  from . import outputs
    12  
    13  __all__ = [
    14      'SsisEnvironmentReferenceResponse',
    15      'SsisEnvironmentResponse',
    16      'SsisFolderResponse',
    17      'SsisPackageResponse',
    18      'SsisParameterResponse',
    19      'SsisProjectResponse',
    20      'SsisVariableResponse',
    21      'StorageAccountKeyResponse',
    22  ]
    23  
    24  @pulumi.output_type
    25  class SsisEnvironmentReferenceResponse(dict):
    26      """
    27      Ssis environment reference.
    28      """
    29      def __init__(__self__, *,
    30                   environment_folder_name: Optional[str] = None,
    31                   environment_name: Optional[str] = None,
    32                   id: Optional[float] = None,
    33                   reference_type: Optional[str] = None):
    34          """
    35          Ssis environment reference.
    36          :param str environment_folder_name: Environment folder name.
    37          :param str environment_name: Environment name.
    38          :param float id: Environment reference id.
    39          :param str reference_type: Reference type
    40          """
    41          if environment_folder_name is not None:
    42              pulumi.set(__self__, "environment_folder_name", environment_folder_name)
    43          if environment_name is not None:
    44              pulumi.set(__self__, "environment_name", environment_name)
    45          if id is not None:
    46              pulumi.set(__self__, "id", id)
    47          if reference_type is not None:
    48              pulumi.set(__self__, "reference_type", reference_type)
    49  
    50      @property
    51      @pulumi.getter(name="environmentFolderName")
    52      def environment_folder_name(self) -> Optional[str]:
    53          """
    54          Environment folder name.
    55          """
    56          return pulumi.get(self, "environment_folder_name")
    57  
    58      @property
    59      @pulumi.getter(name="environmentName")
    60      def environment_name(self) -> Optional[str]:
    61          """
    62          Environment name.
    63          """
    64          return pulumi.get(self, "environment_name")
    65  
    66      @property
    67      @pulumi.getter
    68      def id(self) -> Optional[float]:
    69          """
    70          Environment reference id.
    71          """
    72          return pulumi.get(self, "id")
    73  
    74      @property
    75      @pulumi.getter(name="referenceType")
    76      def reference_type(self) -> Optional[str]:
    77          """
    78          Reference type
    79          """
    80          return pulumi.get(self, "reference_type")
    81  
    82  
    83  @pulumi.output_type
    84  class SsisEnvironmentResponse(dict):
    85      """
    86      Ssis environment.
    87      """
    88      def __init__(__self__, *,
    89                   type: str,
    90                   description: Optional[str] = None,
    91                   folder_id: Optional[float] = None,
    92                   id: Optional[float] = None,
    93                   name: Optional[str] = None,
    94                   variables: Optional[Sequence['outputs.SsisVariableResponse']] = None):
    95          """
    96          Ssis environment.
    97          :param str type: The type of SSIS object metadata.
    98                 Expected value is 'Environment'.
    99          :param str description: Metadata description.
   100          :param float folder_id: Folder id which contains environment.
   101          :param float id: Metadata id.
   102          :param str name: Metadata name.
   103          :param Sequence['SsisVariableResponse'] variables: Variable in environment
   104          """
   105          pulumi.set(__self__, "type", 'Environment')
   106          if description is not None:
   107              pulumi.set(__self__, "description", description)
   108          if folder_id is not None:
   109              pulumi.set(__self__, "folder_id", folder_id)
   110          if id is not None:
   111              pulumi.set(__self__, "id", id)
   112          if name is not None:
   113              pulumi.set(__self__, "name", name)
   114          if variables is not None:
   115              pulumi.set(__self__, "variables", variables)
   116  
   117      @property
   118      @pulumi.getter
   119      def type(self) -> str:
   120          """
   121          The type of SSIS object metadata.
   122          Expected value is 'Environment'.
   123          """
   124          return pulumi.get(self, "type")
   125  
   126      @property
   127      @pulumi.getter
   128      def description(self) -> Optional[str]:
   129          """
   130          Metadata description.
   131          """
   132          return pulumi.get(self, "description")
   133  
   134      @property
   135      @pulumi.getter(name="folderId")
   136      def folder_id(self) -> Optional[float]:
   137          """
   138          Folder id which contains environment.
   139          """
   140          return pulumi.get(self, "folder_id")
   141  
   142      @property
   143      @pulumi.getter
   144      def id(self) -> Optional[float]:
   145          """
   146          Metadata id.
   147          """
   148          return pulumi.get(self, "id")
   149  
   150      @property
   151      @pulumi.getter
   152      def name(self) -> Optional[str]:
   153          """
   154          Metadata name.
   155          """
   156          return pulumi.get(self, "name")
   157  
   158      @property
   159      @pulumi.getter
   160      def variables(self) -> Optional[Sequence['outputs.SsisVariableResponse']]:
   161          """
   162          Variable in environment
   163          """
   164          return pulumi.get(self, "variables")
   165  
   166  
   167  @pulumi.output_type
   168  class SsisFolderResponse(dict):
   169      """
   170      Ssis folder.
   171      """
   172      def __init__(__self__, *,
   173                   type: str,
   174                   description: Optional[str] = None,
   175                   id: Optional[float] = None,
   176                   name: Optional[str] = None):
   177          """
   178          Ssis folder.
   179          :param str type: The type of SSIS object metadata.
   180                 Expected value is 'Folder'.
   181          :param str description: Metadata description.
   182          :param float id: Metadata id.
   183          :param str name: Metadata name.
   184          """
   185          pulumi.set(__self__, "type", 'Folder')
   186          if description is not None:
   187              pulumi.set(__self__, "description", description)
   188          if id is not None:
   189              pulumi.set(__self__, "id", id)
   190          if name is not None:
   191              pulumi.set(__self__, "name", name)
   192  
   193      @property
   194      @pulumi.getter
   195      def type(self) -> str:
   196          """
   197          The type of SSIS object metadata.
   198          Expected value is 'Folder'.
   199          """
   200          return pulumi.get(self, "type")
   201  
   202      @property
   203      @pulumi.getter
   204      def description(self) -> Optional[str]:
   205          """
   206          Metadata description.
   207          """
   208          return pulumi.get(self, "description")
   209  
   210      @property
   211      @pulumi.getter
   212      def id(self) -> Optional[float]:
   213          """
   214          Metadata id.
   215          """
   216          return pulumi.get(self, "id")
   217  
   218      @property
   219      @pulumi.getter
   220      def name(self) -> Optional[str]:
   221          """
   222          Metadata name.
   223          """
   224          return pulumi.get(self, "name")
   225  
   226  
   227  @pulumi.output_type
   228  class SsisPackageResponse(dict):
   229      """
   230      Ssis Package.
   231      """
   232      def __init__(__self__, *,
   233                   type: str,
   234                   description: Optional[str] = None,
   235                   folder_id: Optional[float] = None,
   236                   id: Optional[float] = None,
   237                   name: Optional[str] = None,
   238                   parameters: Optional[Sequence['outputs.SsisParameterResponse']] = None,
   239                   project_id: Optional[float] = None,
   240                   project_version: Optional[float] = None):
   241          """
   242          Ssis Package.
   243          :param str type: The type of SSIS object metadata.
   244                 Expected value is 'Package'.
   245          :param str description: Metadata description.
   246          :param float folder_id: Folder id which contains package.
   247          :param float id: Metadata id.
   248          :param str name: Metadata name.
   249          :param Sequence['SsisParameterResponse'] parameters: Parameters in package
   250          :param float project_id: Project id which contains package.
   251          :param float project_version: Project version which contains package.
   252          """
   253          pulumi.set(__self__, "type", 'Package')
   254          if description is not None:
   255              pulumi.set(__self__, "description", description)
   256          if folder_id is not None:
   257              pulumi.set(__self__, "folder_id", folder_id)
   258          if id is not None:
   259              pulumi.set(__self__, "id", id)
   260          if name is not None:
   261              pulumi.set(__self__, "name", name)
   262          if parameters is not None:
   263              pulumi.set(__self__, "parameters", parameters)
   264          if project_id is not None:
   265              pulumi.set(__self__, "project_id", project_id)
   266          if project_version is not None:
   267              pulumi.set(__self__, "project_version", project_version)
   268  
   269      @property
   270      @pulumi.getter
   271      def type(self) -> str:
   272          """
   273          The type of SSIS object metadata.
   274          Expected value is 'Package'.
   275          """
   276          return pulumi.get(self, "type")
   277  
   278      @property
   279      @pulumi.getter
   280      def description(self) -> Optional[str]:
   281          """
   282          Metadata description.
   283          """
   284          return pulumi.get(self, "description")
   285  
   286      @property
   287      @pulumi.getter(name="folderId")
   288      def folder_id(self) -> Optional[float]:
   289          """
   290          Folder id which contains package.
   291          """
   292          return pulumi.get(self, "folder_id")
   293  
   294      @property
   295      @pulumi.getter
   296      def id(self) -> Optional[float]:
   297          """
   298          Metadata id.
   299          """
   300          return pulumi.get(self, "id")
   301  
   302      @property
   303      @pulumi.getter
   304      def name(self) -> Optional[str]:
   305          """
   306          Metadata name.
   307          """
   308          return pulumi.get(self, "name")
   309  
   310      @property
   311      @pulumi.getter
   312      def parameters(self) -> Optional[Sequence['outputs.SsisParameterResponse']]:
   313          """
   314          Parameters in package
   315          """
   316          return pulumi.get(self, "parameters")
   317  
   318      @property
   319      @pulumi.getter(name="projectId")
   320      def project_id(self) -> Optional[float]:
   321          """
   322          Project id which contains package.
   323          """
   324          return pulumi.get(self, "project_id")
   325  
   326      @property
   327      @pulumi.getter(name="projectVersion")
   328      def project_version(self) -> Optional[float]:
   329          """
   330          Project version which contains package.
   331          """
   332          return pulumi.get(self, "project_version")
   333  
   334  
   335  @pulumi.output_type
   336  class SsisParameterResponse(dict):
   337      """
   338      Ssis parameter.
   339      """
   340      def __init__(__self__, *,
   341                   data_type: Optional[str] = None,
   342                   default_value: Optional[str] = None,
   343                   description: Optional[str] = None,
   344                   design_default_value: Optional[str] = None,
   345                   id: Optional[float] = None,
   346                   name: Optional[str] = None,
   347                   required: Optional[bool] = None,
   348                   sensitive: Optional[bool] = None,
   349                   sensitive_default_value: Optional[str] = None,
   350                   value_set: Optional[bool] = None,
   351                   value_type: Optional[str] = None,
   352                   variable: Optional[str] = None):
   353          """
   354          Ssis parameter.
   355          :param str data_type: Parameter type.
   356          :param str default_value: Default value of parameter.
   357          :param str description: Parameter description.
   358          :param str design_default_value: Design default value of parameter.
   359          :param float id: Parameter id.
   360          :param str name: Parameter name.
   361          :param bool required: Whether parameter is required.
   362          :param bool sensitive: Whether parameter is sensitive.
   363          :param str sensitive_default_value: Default sensitive value of parameter.
   364          :param bool value_set: Parameter value set.
   365          :param str value_type: Parameter value type.
   366          :param str variable: Parameter reference variable.
   367          """
   368          if data_type is not None:
   369              pulumi.set(__self__, "data_type", data_type)
   370          if default_value is not None:
   371              pulumi.set(__self__, "default_value", default_value)
   372          if description is not None:
   373              pulumi.set(__self__, "description", description)
   374          if design_default_value is not None:
   375              pulumi.set(__self__, "design_default_value", design_default_value)
   376          if id is not None:
   377              pulumi.set(__self__, "id", id)
   378          if name is not None:
   379              pulumi.set(__self__, "name", name)
   380          if required is not None:
   381              pulumi.set(__self__, "required", required)
   382          if sensitive is not None:
   383              pulumi.set(__self__, "sensitive", sensitive)
   384          if sensitive_default_value is not None:
   385              pulumi.set(__self__, "sensitive_default_value", sensitive_default_value)
   386          if value_set is not None:
   387              pulumi.set(__self__, "value_set", value_set)
   388          if value_type is not None:
   389              pulumi.set(__self__, "value_type", value_type)
   390          if variable is not None:
   391              pulumi.set(__self__, "variable", variable)
   392  
   393      @property
   394      @pulumi.getter(name="dataType")
   395      def data_type(self) -> Optional[str]:
   396          """
   397          Parameter type.
   398          """
   399          return pulumi.get(self, "data_type")
   400  
   401      @property
   402      @pulumi.getter(name="defaultValue")
   403      def default_value(self) -> Optional[str]:
   404          """
   405          Default value of parameter.
   406          """
   407          return pulumi.get(self, "default_value")
   408  
   409      @property
   410      @pulumi.getter
   411      def description(self) -> Optional[str]:
   412          """
   413          Parameter description.
   414          """
   415          return pulumi.get(self, "description")
   416  
   417      @property
   418      @pulumi.getter(name="designDefaultValue")
   419      def design_default_value(self) -> Optional[str]:
   420          """
   421          Design default value of parameter.
   422          """
   423          return pulumi.get(self, "design_default_value")
   424  
   425      @property
   426      @pulumi.getter
   427      def id(self) -> Optional[float]:
   428          """
   429          Parameter id.
   430          """
   431          return pulumi.get(self, "id")
   432  
   433      @property
   434      @pulumi.getter
   435      def name(self) -> Optional[str]:
   436          """
   437          Parameter name.
   438          """
   439          return pulumi.get(self, "name")
   440  
   441      @property
   442      @pulumi.getter
   443      def required(self) -> Optional[bool]:
   444          """
   445          Whether parameter is required.
   446          """
   447          return pulumi.get(self, "required")
   448  
   449      @property
   450      @pulumi.getter
   451      def sensitive(self) -> Optional[bool]:
   452          """
   453          Whether parameter is sensitive.
   454          """
   455          return pulumi.get(self, "sensitive")
   456  
   457      @property
   458      @pulumi.getter(name="sensitiveDefaultValue")
   459      def sensitive_default_value(self) -> Optional[str]:
   460          """
   461          Default sensitive value of parameter.
   462          """
   463          return pulumi.get(self, "sensitive_default_value")
   464  
   465      @property
   466      @pulumi.getter(name="valueSet")
   467      def value_set(self) -> Optional[bool]:
   468          """
   469          Parameter value set.
   470          """
   471          return pulumi.get(self, "value_set")
   472  
   473      @property
   474      @pulumi.getter(name="valueType")
   475      def value_type(self) -> Optional[str]:
   476          """
   477          Parameter value type.
   478          """
   479          return pulumi.get(self, "value_type")
   480  
   481      @property
   482      @pulumi.getter
   483      def variable(self) -> Optional[str]:
   484          """
   485          Parameter reference variable.
   486          """
   487          return pulumi.get(self, "variable")
   488  
   489  
   490  @pulumi.output_type
   491  class SsisProjectResponse(dict):
   492      """
   493      Ssis project.
   494      """
   495      def __init__(__self__, *,
   496                   type: str,
   497                   description: Optional[str] = None,
   498                   environment_refs: Optional[Sequence['outputs.SsisEnvironmentReferenceResponse']] = None,
   499                   folder_id: Optional[float] = None,
   500                   id: Optional[float] = None,
   501                   name: Optional[str] = None,
   502                   parameters: Optional[Sequence['outputs.SsisParameterResponse']] = None,
   503                   version: Optional[float] = None):
   504          """
   505          Ssis project.
   506          :param str type: The type of SSIS object metadata.
   507                 Expected value is 'Project'.
   508          :param str description: Metadata description.
   509          :param Sequence['SsisEnvironmentReferenceResponse'] environment_refs: Environment reference in project
   510          :param float folder_id: Folder id which contains project.
   511          :param float id: Metadata id.
   512          :param str name: Metadata name.
   513          :param Sequence['SsisParameterResponse'] parameters: Parameters in project
   514          :param float version: Project version.
   515          """
   516          pulumi.set(__self__, "type", 'Project')
   517          if description is not None:
   518              pulumi.set(__self__, "description", description)
   519          if environment_refs is not None:
   520              pulumi.set(__self__, "environment_refs", environment_refs)
   521          if folder_id is not None:
   522              pulumi.set(__self__, "folder_id", folder_id)
   523          if id is not None:
   524              pulumi.set(__self__, "id", id)
   525          if name is not None:
   526              pulumi.set(__self__, "name", name)
   527          if parameters is not None:
   528              pulumi.set(__self__, "parameters", parameters)
   529          if version is not None:
   530              pulumi.set(__self__, "version", version)
   531  
   532      @property
   533      @pulumi.getter
   534      def type(self) -> str:
   535          """
   536          The type of SSIS object metadata.
   537          Expected value is 'Project'.
   538          """
   539          return pulumi.get(self, "type")
   540  
   541      @property
   542      @pulumi.getter
   543      def description(self) -> Optional[str]:
   544          """
   545          Metadata description.
   546          """
   547          return pulumi.get(self, "description")
   548  
   549      @property
   550      @pulumi.getter(name="environmentRefs")
   551      def environment_refs(self) -> Optional[Sequence['outputs.SsisEnvironmentReferenceResponse']]:
   552          """
   553          Environment reference in project
   554          """
   555          return pulumi.get(self, "environment_refs")
   556  
   557      @property
   558      @pulumi.getter(name="folderId")
   559      def folder_id(self) -> Optional[float]:
   560          """
   561          Folder id which contains project.
   562          """
   563          return pulumi.get(self, "folder_id")
   564  
   565      @property
   566      @pulumi.getter
   567      def id(self) -> Optional[float]:
   568          """
   569          Metadata id.
   570          """
   571          return pulumi.get(self, "id")
   572  
   573      @property
   574      @pulumi.getter
   575      def name(self) -> Optional[str]:
   576          """
   577          Metadata name.
   578          """
   579          return pulumi.get(self, "name")
   580  
   581      @property
   582      @pulumi.getter
   583      def parameters(self) -> Optional[Sequence['outputs.SsisParameterResponse']]:
   584          """
   585          Parameters in project
   586          """
   587          return pulumi.get(self, "parameters")
   588  
   589      @property
   590      @pulumi.getter
   591      def version(self) -> Optional[float]:
   592          """
   593          Project version.
   594          """
   595          return pulumi.get(self, "version")
   596  
   597  
   598  @pulumi.output_type
   599  class SsisVariableResponse(dict):
   600      """
   601      Ssis variable.
   602      """
   603      def __init__(__self__, *,
   604                   data_type: Optional[str] = None,
   605                   description: Optional[str] = None,
   606                   id: Optional[float] = None,
   607                   name: Optional[str] = None,
   608                   sensitive: Optional[bool] = None,
   609                   sensitive_value: Optional[str] = None,
   610                   value: Optional[str] = None):
   611          """
   612          Ssis variable.
   613          :param str data_type: Variable type.
   614          :param str description: Variable description.
   615          :param float id: Variable id.
   616          :param str name: Variable name.
   617          :param bool sensitive: Whether variable is sensitive.
   618          :param str sensitive_value: Variable sensitive value.
   619          :param str value: Variable value.
   620          """
   621          if data_type is not None:
   622              pulumi.set(__self__, "data_type", data_type)
   623          if description is not None:
   624              pulumi.set(__self__, "description", description)
   625          if id is not None:
   626              pulumi.set(__self__, "id", id)
   627          if name is not None:
   628              pulumi.set(__self__, "name", name)
   629          if sensitive is not None:
   630              pulumi.set(__self__, "sensitive", sensitive)
   631          if sensitive_value is not None:
   632              pulumi.set(__self__, "sensitive_value", sensitive_value)
   633          if value is not None:
   634              pulumi.set(__self__, "value", value)
   635  
   636      @property
   637      @pulumi.getter(name="dataType")
   638      def data_type(self) -> Optional[str]:
   639          """
   640          Variable type.
   641          """
   642          return pulumi.get(self, "data_type")
   643  
   644      @property
   645      @pulumi.getter
   646      def description(self) -> Optional[str]:
   647          """
   648          Variable description.
   649          """
   650          return pulumi.get(self, "description")
   651  
   652      @property
   653      @pulumi.getter
   654      def id(self) -> Optional[float]:
   655          """
   656          Variable id.
   657          """
   658          return pulumi.get(self, "id")
   659  
   660      @property
   661      @pulumi.getter
   662      def name(self) -> Optional[str]:
   663          """
   664          Variable name.
   665          """
   666          return pulumi.get(self, "name")
   667  
   668      @property
   669      @pulumi.getter
   670      def sensitive(self) -> Optional[bool]:
   671          """
   672          Whether variable is sensitive.
   673          """
   674          return pulumi.get(self, "sensitive")
   675  
   676      @property
   677      @pulumi.getter(name="sensitiveValue")
   678      def sensitive_value(self) -> Optional[str]:
   679          """
   680          Variable sensitive value.
   681          """
   682          return pulumi.get(self, "sensitive_value")
   683  
   684      @property
   685      @pulumi.getter
   686      def value(self) -> Optional[str]:
   687          """
   688          Variable value.
   689          """
   690          return pulumi.get(self, "value")
   691  
   692  
   693  @pulumi.output_type
   694  class StorageAccountKeyResponse(dict):
   695      """
   696      An access key for the storage account.
   697      """
   698      def __init__(__self__, *,
   699                   creation_time: str,
   700                   key_name: str,
   701                   permissions: str,
   702                   value: str):
   703          """
   704          An access key for the storage account.
   705          :param str creation_time: Creation time of the key, in round trip date format.
   706          :param str key_name: Name of the key.
   707          :param str permissions: Permissions for the key -- read-only or full permissions.
   708          :param str value: Base 64-encoded value of the key.
   709          """
   710          pulumi.set(__self__, "creation_time", creation_time)
   711          pulumi.set(__self__, "key_name", key_name)
   712          pulumi.set(__self__, "permissions", permissions)
   713          pulumi.set(__self__, "value", value)
   714  
   715      @property
   716      @pulumi.getter(name="creationTime")
   717      def creation_time(self) -> str:
   718          """
   719          Creation time of the key, in round trip date format.
   720          """
   721          return pulumi.get(self, "creation_time")
   722  
   723      @property
   724      @pulumi.getter(name="keyName")
   725      def key_name(self) -> str:
   726          """
   727          Name of the key.
   728          """
   729          return pulumi.get(self, "key_name")
   730  
   731      @property
   732      @pulumi.getter
   733      def permissions(self) -> str:
   734          """
   735          Permissions for the key -- read-only or full permissions.
   736          """
   737          return pulumi.get(self, "permissions")
   738  
   739      @property
   740      @pulumi.getter
   741      def value(self) -> str:
   742          """
   743          Base 64-encoded value of the key.
   744          """
   745          return pulumi.get(self, "value")
   746  
   747